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

Visual C# Consolidado

2

CRIANDO E ACESSANDO SERVIÇOS DA WEB (VISUAL C#)...........................................................67 CRIANDO COMPONENTES (VISUAL C#)....................................................................................................68 DESENVOLVENDO NA PLATAFORMA DO OFFICE (VISUAL C#) ......................................................................................68 Programação do Office (Como Fazer em C#).........................................................................................................68 Como: Atualizar soluções das Ferramentas do Visual Studio para o Office ..........................................................69 O EXCEL USANDO EXPLICAÇÕES PASSO-A-PASSO.............................................................................71 COLETA DE DADOS USANDO UM FORMULÁRIO DO WINDOWS WALKTHROUGH .............................................................71 ALTERANDO PLANILHA FORMATAÇÃO USANDO CONTROLES CHECKBOX WALKTHROUGH: .........................................73 EXIBINDO TEXTO EM UMA CAIXA DE TEXTO EM UMA PLANILHA USANDO UM BOTÃO WALKTHROUGH: ........................76 PROGRAMAÇÃO CONTRA EVENTOS DE UM CONTROLE NAMEDRANGE WALKTHROUGH:...............................................78 PASSO-A-PASSO: CONCEDENDO E REMOVENDO PERMISSÕES PARA UMA SOLUÇÃO DO OFFICE .....................................81 PASSO-A-PASSO: LIGANDO UMA CÉLULA DE PLANILHA A UM CAMPO DE BANCO DE DADOS ..........................................84 WALKTHROUGH: VINCULAÇÃO CÉLULAS PARA VÁRIAS COLUNAS EM UMA TABELA .....................................................87 CRIANDO UMA RELAÇÃO MESTRE / DETALHES USANDO UM DATASET EM CACHE WALKTHROUGH: .............................91 WALKTHROUGH: ATUALIZANDO UM GRÁFICO EM UMA PLANILHA USANDO BOTÕES DE OPÇÃO ....................................94 VINCULAÇÃO DE DADOS PARA CONTROLES EM UM PAINEL AÇÕES DO EXCEL WALKTHROUGH: ..................................99 IMPLANTANDO UM WORD OU SOLUTION DO EXCEL USANDO UM MANIFESTO DEPLOYMENT WALKTHROUGH: ..........103 IMPLANTANDO UM WORD OU SOLUTION DO EXCEL USANDO UM ARQUIVO DO WINDOWS INSTALLER WALKTHROUGH: ....................................................................................................................................................................................107 PASSO-A-PASSO: CONCEDENDO E REMOVENDO PERMISSÕES PARA UMA SOLUÇÃO DO OFFICE ...................................112 O WORD USANDO EXPLICAÇÕES PASSO-A-PASSO ..........................................................................116 WALKTHROUGH: CHANGING DOCUMENT FORMATAÇÃO USANDO CONTROLES CHECKBOX .......................................116 EXIBINDO TEXTO EM UMA CAIXA DE TEXTO EM UM DOCUMENTO USANDO UM BOTÃO WALKTHROUGH:....................119 WALKTHROUGH: CRIANDO MENUS DE ATALHO PARA INDICADORES ...........................................................................121 WALKTHROUGH: ATUALIZANDO UM GRÁFICO EM UM DOCUMENTO USANDO BOTÕES DE OPÇÃO ................................124 VINCULAÇÃO DE DADOS PARA CONTROLES EM UM PAINEL AÇÕES DO WORD WALKTHROUGH: ................................128 WALKTHROUGH: CRIAR UMA MARCA INTELIGENTE QUE CONVERTE TEMPERATURES DE FAHRENHEIT PARA CELSIUS133 IMPLANTANDO UM WORD OU SOLUTION DO EXCEL USANDO UM MANIFESTO DEPLOYMENT WALKTHROUGH: ..........135 IMPLANTANDO UM WORD OU SOLUTION DO EXCEL USANDO UM ARQUIVO DO WINDOWS INSTALLER WALKTHROUGH: ....................................................................................................................................................................................139 PASSO-A-PASSO: CONCEDENDO E REMOVENDO PERMISSÕES PARA UMA SOLUÇÃO DO OFFICE ...................................144 COMO: ADICIONAR CONTROLES A DOCUMENTOS DO OFFICE ...................................................................................147 COMO: EXECUTAR CÁLCULOS DO EXCEL POR PROGRAMAÇÃO.................................................................................149 COMO: CRIAR MENUS DO OFFICE PROGRAMATICAMENTE ...........................................................................................149 COMO: CRIAR BARRAS DE FERRAMENTAS DO OFFICE POR PROGRAMAÇÃO .............................................................150 DESENVOLVIMENTO CORPORATIVO (VISUAL C#)...........................................................................152 PROGRAMAÇÃO DO TABLET PC (VISUAL C#) ..........................................................................................152 ÁUDIO, VÍDEO, JOGOS E ELEMENTOS GRÁFICOS (VISUAL C#) ......................................................152 CRIANDO STARTER KITS (VISUAL C#).......................................................................................................154 MIGRANDO PARA O VISUAL C#...................................................................................................................155 C# PARA DESENVOLVEDORES JAVA ............................................................................................................................155 CONVERTENDO APLICATIVOS JAVA PARA VISUAL C#.................................................................................................155 PARA DESENVOLVEDORES C++ C# .............................................................................................................................155 GUIA DE PROGRAMAÇÃO C# .........................................................................................................................158 EM UM PROGRAMA C# ................................................................................................................................................158 Hello world-seu primeiro programa (guia de programação C#)..........................................................................159 Estrutura geral de um programa C# (guia de programação C#)..........................................................................160 MAIN() E ARGUMENTOS DE LINHA DE COMANDO (GUIA DE PROGRAMAÇÃO C#) ........................................................160 ARGUMENTOS DE LINHA DE COMANDO (GUIA DE PROGRAMAÇÃO C#)........................................................................161 COMO: EXIBIR ARGUMENTOS DE LINHA DE COMANDO (GUIA DE PROGRAMAÇÃO C#) ..............................................162 COMO: ACESSAR ARGUMENTOS DE LINHA DE COMANDO USANDO FOREACH (GUIA DE PROGRAMAÇÃO C#).............163 MAIN() RETORNA VALORES (GUIA DE PROGRAMAÇÃO C#).........................................................................................163 TIPOS DE DADOS (GUIA DE PROGRAMAÇÃO C#) ..........................................................................................................164 MATRIZES (GUIA DE PROGRAMAÇÃO DO C#).....................................................................................165 MATRIZES COMO OBJETOS (GUIA DE PROGRAMAÇÃO C#) ...........................................................................................165

Visual C# Consolidado

3

MATRIZES MULTIDIMENSIONAIS (GUIA DE PROGRAMAÇÃO C#) ..................................................................................166 MATRIZES PASSAGEM COMO PARÂMETROS (GUIA DE PROGRAMAÇÃO C#)..................................................................166 PASSANDO REF USANDO MATRIZES E OUT (GUIA PROGRAMAÇÃO C#) .......................................................................168 SEQÜÊNCIAS (GUIA DE PROGRAMAÇÃO C#) ................................................................................................................169 USANDO STRINGS (GUIA DE PROGRAMAÇÃO C#) ........................................................................................................169 ESPECIFICAÇÃO DA LINGUAGEM C# ........................................................................................................173 REFERÊNCIA C# ....................................................................................................................................................174 PALAVRAS-CHAVE C#.................................................................................................................................................174 PALAVRA-CHAVE ABSTRACT.......................................................................................................................................174 PALAVRA-CHAVE EVENT .............................................................................................................................................177 PALAVRA-CHAVE NEW ................................................................................................................................................181 OPERADOR NEW ....................................................................................................................................................181 MODIFICADOR NEW..............................................................................................................................................184 PALAVRA-CHAVE STRUCT..................................................................................................................................186 PALAVRA-CHAVE AS............................................................................................................................................189 PALAVRA-CHAVE EXPLICIT .........................................................................................................................................190 PALAVRA-CHAVE NULL ...............................................................................................................................................191 PALAVRA-CHAVE SWITCH ...........................................................................................................................................192 PALAVRA-CHAVE BASE ...............................................................................................................................................194 PALAVRA-CHAVE EXTERN...........................................................................................................................................196 PALAVRA-CHAVE OBJECT ...........................................................................................................................................197 PALAVRA-CHAVE THIS ................................................................................................................................................198 PALAVRA-CHAVE BOOL ..............................................................................................................................................200 PALAVRA-CHAVE FALSE .............................................................................................................................................201 OPERADOR FALSE .................................................................................................................................................201 FALSE (LITERAL) ...................................................................................................................................................201 PALAVRA-CHAVE OPERATOR ......................................................................................................................................202 PALAVRA-CHAVE THROW ...........................................................................................................................................204 PALAVRA-CHAVE BREAK ............................................................................................................................................205 PALAVRA-CHAVE TRY-FINALLY ..................................................................................................................................206 PALAVRA-CHAVE OUT.................................................................................................................................................207 PALAVRA-CHAVE TRUE ...............................................................................................................................................208 OPERADOR TRUE...................................................................................................................................................208 TRUE (LITERAL) .....................................................................................................................................................208 PALAVRA-CHAVE BYTE ...............................................................................................................................................209 PALAVRA-CHAVE FIXED ..............................................................................................................................................210 PALAVRA-CHAVE OVERRIDE .......................................................................................................................................212 PALAVRA-CHAVE TRY-CATCH .....................................................................................................................................213 PALAVRA-CHAVE SWITCH ...........................................................................................................................................216 PALAVRA-CHAVE FOAT ...............................................................................................................................................218 PALAVRA-CHAVE PARAMS ..........................................................................................................................................219 PALAVRA-CHAVE TYPEOF ...........................................................................................................................................220 PALAVRA-CHAVE TRY-CATCH .....................................................................................................................................222 PALAVRA-CHAVE FOR .................................................................................................................................................225 PALAVRA-CHAVE PRIVATE ..........................................................................................................................................226 PALAVRA-CHAVE UINT................................................................................................................................................227 PALAVRA-CHAVE CHAR......................................................................................................................................228 PALAVRA-CHAVE FOREACH, IN ...................................................................................................................................228 PALAVRA-CHAVE VOLATILE .......................................................................................................................................229 PALAVRA-CHAVE DELEGATE.......................................................................................................................................230 PALAVRA-CHAVE OCK ................................................................................................................................................232 PALAVRA-CHAVE STACKALOC ....................................................................................................................................234 OPERADORES C# ..................................................................................................................................................237 OPERADORES SOBRECARREGADOS ..........................................................................................................................238 OPERADOR [ ]..............................................................................................................................................................239 OPERADOR ( )..............................................................................................................................................................240 OPERADOR . (PONTO) ..................................................................................................................................................241 OPERADOR + ...............................................................................................................................................................241 OPERADOR -................................................................................................................................................................242 OPERADOR * ...............................................................................................................................................................243

Visual C# Consolidado

4

OPERADOR / ................................................................................................................................................................244 OPERADOR %..............................................................................................................................................................245 OPERADOR & ..............................................................................................................................................................245 OPERADOR | ................................................................................................................................................................246 OPERADOR ^ ...............................................................................................................................................................247 OPERADOR !................................................................................................................................................................248 OPERADOR ~ ...............................................................................................................................................................248 OPERADOR = ...............................................................................................................................................................249 OPERADOR < ...............................................................................................................................................................250 OPERADOR > ...............................................................................................................................................................250 OPERADOR ?: ..............................................................................................................................................................251 OPERADOR ++.............................................................................................................................................................252 OPERADOR -- ..............................................................................................................................................................253 OPERADOR && ...........................................................................................................................................................254 DIRECTIVES PREPROCESSOR C# ................................................................................................................256 #IF (REFERÊNCIA C#) ..................................................................................................................................................256 #ELSE PESSOA (REFERÊNCIA C#) ................................................................................................................................257 #ENDIF (REFERÊNCIA C#)............................................................................................................................................257 # DEFINIR (REFERÊNCIA C#) .......................................................................................................................................258 #UNDEF (REFERÊNCIA C#)...........................................................................................................................................258 #WARNING (REFERÊNCIA C#)......................................................................................................................................258 #ERROR (REFERÊNCIA C#) ..........................................................................................................................................259 # LINE (REFERÊNCIA C#).............................................................................................................................................259 #REGION (REFERÊNCIA C#).........................................................................................................................................260 #ENDREGION (REFERÊNCIA C#)...................................................................................................................................260 # PRAGMA (REFERÊNCIA C#).......................................................................................................................................260 AVISO # PRAGMA (REFERÊNCIA C#)............................................................................................................................260 SOMA DE VERIFICAÇÃO # PRAGMA (REFERÊNCIA C#) .................................................................................................261 OPÇÕES DO COMPILADOR C#.......................................................................................................................262 CRIANDO DE LINHA DE COMANDO ...............................................................................................................................262 COMO CONSTRUIR A PARTIR DA LINHA DE COMANDO: ................................................................................................263 IMPLANTAÇÃO DE APLICATIVOS C# ........................................................................................................264 OPÇÕES DO COMPILADOR C# LISTADAS POR CATEGORIA ............................................................................................264 Otimização.............................................................................................................................................................264 Arquivos de saída ..................................................................................................................................................264 Conjuntos .NET Framework..................................................................................................................................264 Erros Debugging / verificação ..............................................................................................................................265 Preprocessor .........................................................................................................................................................265 Recursos ................................................................................................................................................................265 Diversos.................................................................................................................................................................265 OPÇÕES DO COMPILADOR C# LISTADAS ALFABETICAMENTE ......................................................................................266 COMO LOCALIZAR AJUDA PARA ERROS DO COMPILADOR: ...........................................................................................267 PARA ENCONTRAR AJUDA PARA UM ERRO ..................................................................................................................267 EXEMPLOS DO VISUAL C#...............................................................................................................................268 EXEMPLO WORLD DE SAUDAÇÃO................................................................................................................................269 EXEMPLO DE PARÂMETROS DA LINHA DE COMANDO ...................................................................................................271 EXEMPLO MATRIZES ...................................................................................................................................................272 EXEMPLO PROPRIEDADES ............................................................................................................................................272 EXEMPLO BIBLIOTECAS ...............................................................................................................................................273 EXEMPLO DE VERSÃO ..................................................................................................................................................274 COLEÇÃO EXEMPLO CLASSES .....................................................................................................................................275 EXEMPLO STRUCTS .....................................................................................................................................................276 EXEMPLO INDEXADORES .............................................................................................................................................277 INDEXADO EXEMPLO PROPRIEDADES ..........................................................................................................................278 EXEMPLO CONVERSIONS DEFINIDAS PELO USUÁRIO ...................................................................................................279 EXEMPLO GENERICS (C#)............................................................................................................................................279 EXEMPLO REPRESENTANTES .......................................................................................................................................281 EXEMPLO EVENTOS .....................................................................................................................................................282

Visual C# Consolidado

5

EXEMPLO DE IMPLEMENTAÇÃO DE INTERFACE EXPLÍCITA ..........................................................................................283 EXEMPLO DOS MÉTODOS CONDICIONAL .....................................................................................................................284 EXEMPLO DE DOCUMENTAÇÃO XML..........................................................................................................................285 PLATAFORMA INVOKE EXEMPLO ................................................................................................................................286 EXEMPLO PARTE 1 INTEROP COM ..............................................................................................................................287 EXEMPLO PARTE 2 INTEROP COM ..............................................................................................................................288 EXEMPLO ATRIBUTOS..................................................................................................................................................289 EXEMPLO DE SEGURANÇA ...........................................................................................................................................290 SEGMENTAÇÃO DE EXEMPLO ......................................................................................................................................291 EXEMPLO DE CÓDIGO NÃO SEGUROS ...........................................................................................................................292 EXEMPLO BD OLE .....................................................................................................................................................293 PRODUZIR EXEMPLO ...................................................................................................................................................294 ANÔNIMO EXEMPLO REPRESENTANTES .......................................................................................................................295 EXEMPLO TIPOS PARCIAL ............................................................................................................................................296 EXEMPLO ANULÁVEL ..................................................................................................................................................296 TERMINOLOGIA C# .............................................................................................................................................298 EXEMPLOS DO VISUAL C#...............................................................................................................................301 EXEMPLO WORLD DE SAUDAÇÃO................................................................................................................................303 EXEMPLO DE PARÂMETROS DA LINHA DE COMANDO ...................................................................................................304 EXEMPLO MATRIZES ...................................................................................................................................................305 EXEMPLO PROPRIEDADES ............................................................................................................................................306 EXEMPLO BIBLIOTECAS ...............................................................................................................................................307 EXEMPLO DE VERSÃO ..................................................................................................................................................308 COLEÇÃO EXEMPLO CLASSES .....................................................................................................................................309 EXEMPLO STRUCTS .....................................................................................................................................................310 EXEMPLO INDEXADORES .............................................................................................................................................311 INDEXADO EXEMPLO PROPRIEDADES ..........................................................................................................................311 EXEMPLO CONVERSIONS DEFINIDAS PELO USUÁRIO ...................................................................................................312 EXEMPLO GENERICS (C#)............................................................................................................................................313 EXEMPLO OVERLOADING DO OPERADOR ....................................................................................................................314 EXEMPLO REPRESENTANTES .......................................................................................................................................315 EXEMPLO EVENTOS .....................................................................................................................................................316 EXEMPLO DE IMPLEMENTAÇÃO DE INTERFACE EXPLÍCITA ..........................................................................................317 EXEMPLO DOS MÉTODOS CONDICIONAL .....................................................................................................................318 EXEMPLO DE DOCUMENTAÇÃO XML..........................................................................................................................318 PLATAFORMA INVOKE EXEMPLO ................................................................................................................................319 EXEMPLO PARTE 1 INTEROP COM ..............................................................................................................................320 EXEMPLO PARTE 2 INTEROP COM ..............................................................................................................................322 EXEMPLO ATRIBUTOS..................................................................................................................................................323 EXEMPLO DE SEGURANÇA ...........................................................................................................................................324 SEGMENTAÇÃO DE EXEMPLO ......................................................................................................................................325 EXEMPLO DE CÓDIGO NÃO SEGUROS ...........................................................................................................................326 EXEMPLO BD OLE .....................................................................................................................................................327 PRODUZIR EXEMPLO ...................................................................................................................................................328 ANÔNIMO EXEMPLO REPRESENTANTES .......................................................................................................................328 EXEMPLO TIPOS PARCIAL ............................................................................................................................................329 EXEMPLO ANULÁVEL ..................................................................................................................................................330 COMO FAZER EM C#................................................................................................................................................332 LINGUAGEM C# (COMO EU FAÇO EM C#).........................................................................................................334 O QUE HÁ DE NOVO NA C# 2.0 IDIOMA E COMPILER ....................................................................................................340 Usando Starter Kits C# .........................................................................................................................................340 Especificação da Linguagem C# ...........................................................................................................................341 Main() e argumentos de linha de comando (Guia de programação C#)...............................................................341 Main() retorna valores (Guia de programação C#)..............................................................................................343 base (Referência do C#) ........................................................................................................................................343 Construtores de instância (Guia de programação C#) .........................................................................................345 CLASSES GENÉRICAS NO .NET FRAMEWORK ..............................................................................................................357 Visão geral sobre Generics no .NET Framework..................................................................................................357 Tipos e Generics aninhadas ..................................................................................................................................358 System.Collections.Generic ...................................................................................................................................359

Visual C# Consolidado

6

System.Collections.ObjectModel ...........................................................................................................................359 O encadeamento representantes............................................................................................................................361 Igualdade e classificação Comparisons ................................................................................................................361 Funcionalidade coleção ........................................................................................................................................361 Vantagens de Generics ..........................................................................................................................................362 A palavra-chave default em código fonte "genérico" (Guia de programação C#) ...............................................363 Métodos genérico (Guia de programação C#)......................................................................................................363 Restrições em parâmetros de tipo (Guia de programação C#) .............................................................................365 Representantes genéricos (Guia de programação C#)..........................................................................................367 Uma tabela imposto exemplo ................................................................................................................................375 Criar um suplemento de automação para Excel usando o Visual Studio e código gerenciado ............................375 Executar o suplemento do Excel............................................................................................................................376 Executar código em outro domínio de aplicação (Guia de programação C#)......................................................392 Exemplos do Visual C#..........................................................................................................................................394 .NET FRAMEWORK (COMO FAZER EM C#).......................................................................................................397 INTRODUÇÃO À LINGUAGEM C# E AO .NET FRAMEWORK ..........................................................................................408 Visão geral sobre o .NET Framework...................................................................................................................410 Visão Geral Conceitual Sobre o .NET Framework ...............................................................................................410 COMMON LANGUAGE RUNTIME ..................................................................................................................................416 Visão geral do Common Language Runtime .........................................................................................................416 Gerenciamento automático de memória................................................................................................................417 CTS (Common Type System) .................................................................................................................................420 Visão Geral do CTS (Common Type System) ........................................................................................................420 Definições de Tipo.................................................................................................................................................422 Membros de Tipos .................................................................................................................................................424 Tipos de valor no Common Type System...............................................................................................................426 Classes no Common Type System..........................................................................................................................427 Delegados no Common Type System.....................................................................................................................428 Matrizes em Common Type System .......................................................................................................................430 Interfaces no Common Type System ......................................................................................................................431 Ponteiros no Common Type System (CTS) ............................................................................................................431 OS METADADOS E OS COMPONENTES AUTODESCRITIVOS ............................................................................................433 Visão Geral Sobre Metadados...............................................................................................................................433 Estrutura e uso de metadados ...............................................................................................................................434 Metadados e Estrutura do Arquivos PE ................................................................................................................434 Uso de metadados em tempo de execução.............................................................................................................435 ASSEMBLIES NO COMMON LANGUAGE RUNTIME........................................................................................................436 Visão Geral Sobre Assemblies...............................................................................................................................437 Benefícios do Assembly .........................................................................................................................................438 Sumário de assembly .............................................................................................................................................439 Manifesto do Assembly ..........................................................................................................................................440 Cache Global de Assemblies .................................................................................................................................442 Assemblies de Nomes Fortes .................................................................................................................................443 Considerações sobre segurança de assemblies .....................................................................................................443 Versionamento de Assembly ..................................................................................................................................445 Número de Versão do Assembly ............................................................................................................................446 Versão Informativa do Assembly ...........................................................................................................................447 Posicionamento do Assembly ................................................................................................................................447 Assemblies e execução lado a lado........................................................................................................................448 Visão Geral da Biblioteca de Classes do .NET Framework..................................................................................448 Localizador rápido de tecnologia..........................................................................................................................451 Criando Novas Seqüências de Caracteres.............................................................................................................458 Aparando e Removendo Caracteres ......................................................................................................................460 Preenchendo Seqüências de Caracteres................................................................................................................461 Comparando Seqüências de Caracteres................................................................................................................462 Alterando a Caixa..................................................................................................................................................466 Usando a Classe StringBuilder .............................................................................................................................467 Acrescentar............................................................................................................................................................468 Coleções e Estruturas de Dados............................................................................................................................472 Definir coleções.....................................................................................................................................................472 Comumente usados tipos da coleção.....................................................................................................................474 Coleções de bits.....................................................................................................................................................474

Visual C# Consolidado

7

Coleções especializados ........................................................................................................................................475 Criando e Manipulating coleções..........................................................................................................................475 Selecionando uma Classe de Coleção ...................................................................................................................476 Enumerar uma coleção..........................................................................................................................................477 Coleções e sincronização (segurança do segmento) .............................................................................................478 Comparações e classifica em coleções..................................................................................................................478 Quando Usar Coleções Genéricas ........................................................................................................................479 Classe genérica List ..............................................................................................................................................480 Considerações sobre desempenho.........................................................................................................................481 Classe genérica SortedDictionary.........................................................................................................................483 DEPURAÇÃO (COMO FAZER EM C#) ............................................................................................................................495 Compilando no Visual Studio ................................................................................................................................495 Compilação Durante o Desenvolvimento de Aplicativos ......................................................................................495 Configurações de Compilação ..............................................................................................................................496 Compilar plataformas ...........................................................................................................................................498 Compilar elementos de interface do usuário.........................................................................................................504 Caixa de Diálogo Batch Build...............................................................................................................................504 Janela de saída ......................................................................................................................................................506 Caixa de Diálogo Configuration Manager............................................................................................................507 Depuração no Visual Studio..................................................................................................................................508 O que há de novo no depurador Visual Studio 2005 .............................................................................................508 Segurança do Depurador ......................................................................................................................................511 Segurança de Depuração Gerenciada...................................................................................................................511 Segurança em Depuração Remota ........................................................................................................................511 Segurança de Depuração de Serviços da Web ......................................................................................................512 Componentes Externos ..........................................................................................................................................512 Símbolos e Código Fonte.......................................................................................................................................512 Preparação e configurações de depuração ...........................................................................................................512 Configurações do Projeto do Depurador ..............................................................................................................513 Requisitos de software depuração SQL.................................................................................................................513 Configurações do projeto para um C++ depurar configuração...........................................................................515 Como definir permissões SQL Server para depuração: ........................................................................................518 Configurações do projeto para uma configuração de depuração no Visual Basic ...............................................519 Arquivos PDB (C++) ............................................................................................................................................521 Arquivos DBG .......................................................................................................................................................521 Instalando símbolos para sistema de depuração chamada Crashes .....................................................................522 Depuração de projetos DLL ..................................................................................................................................523 Preparação da depuração: Projetos de console ...................................................................................................526 Preparação de Depuração: Tipos de Projeto do Visual C++ ..............................................................................526 Preparação da Depuração: Configurações de Propriedades Recomendáveis .....................................................527 Depuração preparação: Applications formulários Windows (.NET)....................................................................527 Projetos Win32 depuração preparação: ...............................................................................................................528 Preparação da Depuração: Web Services XML (C++)........................................................................................529 Preparação para depuração: tipos de projeto C#, J# e Visual Basic ...................................................................529 Aplicativos da Web depuração preparação: .........................................................................................................529 Preparação para depuração : Aplicativos ASP.NET da Web ...............................................................................530 Projetos Serviço da Web XML depuração preparação:........................................................................................530 Preparação para depuração: Serviços da Web ATL Server..................................................................................532 Preparação para depuração: Projetos ATL Server ..............................................................................................532 Instalação de depuração remota ...........................................................................................................................533 Depuração na uma plataforma de 64 bits .............................................................................................................539 Depuração e o processo Hosting...........................................................................................................................540 Explicação detalhada sobre o depurador..............................................................................................................542 Depurando o código gerenciado ...........................................................................................................................542 Diagnóstico de mensagens na janela de saída ......................................................................................................542 Asserção no código gerenciado.............................................................................................................................543 Parar instruções no Visual Basic ..........................................................................................................................546 Depurar o método OnStart como: .........................................................................................................................549 Depuração de código nativo..................................................................................................................................551 Como debug otimizado código: .............................................................................................................................551 DebugBreak e __debugbreak ................................................................................................................................553 Declarações...........................................................................................................................................................553 _DEBUG ...............................................................................................................................................................554

Visual C# Consolidado

8

Detecção vazamento de memória e isolamento.....................................................................................................555 Para depurar código de montagem embutido .......................................................................................................556 Técnicas de depuração atl.....................................................................................................................................556 Técnicas de depuração MFC.................................................................................................................................557 Técnicas de depuração CRT..................................................................................................................................558 Depuração Native FAQs do código.......................................................................................................................559 COM e depurando ActiveX....................................................................................................................................560 Depurar aplicativos da Web..................................................................................................................................562 Depuração SQL .....................................................................................................................................................563 Depuração referência Interface de usuário...........................................................................................................564 Aperfeiçoando a depuração com o atributo de exibição do depurador ................................................................573 Descrição...............................................................................................................................................................575 Código ...................................................................................................................................................................575 Para criar o formulário do Windows para essa explicação passo a passo...........................................................579 Para anexar ao formulário do Windows para depuração.....................................................................................581 Banco de dados de depuração T-SQL ...................................................................................................................590 SEGURANÇA (COMO FAZER EM C#) ............................................................................................................................596 Segurança no Visual Studio...................................................................................................................................596 Noções Básicas sobre Segurança de Accesso a Código........................................................................................596 Práticas recomendadas de política de segurança .................................................................................................597 Visão geral da administração de política de segurança .......................................................................................597 Administração de diretiva de segurança geral......................................................................................................599 Determinando quando para modificar a diretiva de segurança............................................................................599 Ferramentas de administração..............................................................................................................................600 Aumentar permissões.............................................................................................................................................601 Administração com atributos Grupo de códigos ...................................................................................................602 Dicas de administração.........................................................................................................................................603 Administração de diretiva corporativa..................................................................................................................604 Administração de diretiva da máquina..................................................................................................................604 Administração de diretiva de usuário....................................................................................................................604 EXPLICAÇÕES PASSO-A-PASSO DO .NET FRAMEWORK SDK ......................................................................................719 Como Registrar Assemblies de Interoperabilidade Primários ..............................................................................784 Como Empacotar Várias Versões de Bibliotecas de Tipos ...................................................................................785 APLICATIVOS DO WINDOWS (COMO FAZER EM C#) ....................................................................................................786 Componente Timer (Windows Forms)...................................................................................................................797 Visão geral do componente de timer (Windows Forms)........................................................................................797 Limitações do componente Timer de formulários do Windows na propriedade Interval......................................798 Controle toolBar Windows (formulários)..............................................................................................................800 Visão geral sobre de controle toolBar (formulários do Windows)........................................................................800 Como adicionar botões a um controle ToolBar usando o criador:.......................................................................801 PÁGINAS DA WEB E SERVIÇOS DA WEB (COMO FAZER EM C#)................................................................806 O que há de novo no desenvolvimento para Web no Visual Studio.......................................................................806 Servidor de Desenvolvimento do ASP.NET ...........................................................................................................807 Publicação de Web Sites .......................................................................................................................................808 Extensibilidade de Controle ..................................................................................................................................811 Ligação de Dados com Controles de Fonte de Dados ..........................................................................................812 Controles de dados avançados ..............................................................................................................................812 Vinculação bidirecional de dados .........................................................................................................................813 Armazenamento de seqüência de caracteres de conexão ......................................................................................813 Acesso a dados em duas e três camadas ...............................................................................................................813 Compatibilidade com Versões Anteriores para Acesso a Dados ..........................................................................814 INTRODUÇÃO A PÁGINAS DA WEB DO ASP.NET.........................................................................................................815 Postagem cruzada de páginas ...............................................................................................................................816 Preservando o estado da página ...........................................................................................................................816 Controles de servidor ............................................................................................................................................817 Compatibilidade do navegador .............................................................................................................................818 Documentos e dados XML.....................................................................................................................................818 O que há de novo no System.Xml ..........................................................................................................................818 Migrando de versão 1.1 das classes XML .............................................................................................................819 Arquitetura Overview of XML no .NET Framework .............................................................................................822 Segurança e seus aplicativos System.Xml .............................................................................................................822 Considerações sobre segurança System.Xml.........................................................................................................823

Visual C# Consolidado

9

Processamento DTD..............................................................................................................................................824 Processamento de esquema ...................................................................................................................................824 Recursos externos..................................................................................................................................................824 Compartilhar objetos XmlReaderSettings .............................................................................................................825 Suporte componentes.............................................................................................................................................825 Processamento de dados .......................................................................................................................................825 Processamento DTD..............................................................................................................................................825 Tratamento de entidade .........................................................................................................................................825 Recursos externos..................................................................................................................................................825 Recursos externos..................................................................................................................................................826 Blocos de script .....................................................................................................................................................826 Objetos de extensão...............................................................................................................................................826 System.Xml codificação diretrizes .........................................................................................................................827 Acesso externo .......................................................................................................................................................827 Negação de Serviço ...............................................................................................................................................827 Processamento.......................................................................................................................................................828 Dados XML processo In-Memory..........................................................................................................................829 Processo dados XML usando o modelo DOM.......................................................................................................829 Processo dados XML usando o modelo de dados XPath.......................................................................................830 Lendo XML com o XmlReader...............................................................................................................................831 Escrevendo XML com o XmlWriter .......................................................................................................................832 Novos recursos na classe XmlWriter.....................................................................................................................832 Verificação de caracteres......................................................................................................................................833 Verificando a conformidade ..................................................................................................................................833 Usando o XmlWriter..............................................................................................................................................833 Transformações em XSLT......................................................................................................................................834 Usando a classe XslCompiledTransform...............................................................................................................834 Migrando da classe XslTransform ........................................................................................................................835 Considerações sobre segurança XSLT ..................................................................................................................837 Transformações em XSLT com a classe XslTransform..........................................................................................839 Modelo de objeto de esquema (SOM) do XML......................................................................................................841 Visão geral do modelo de objeto do esquema XML ..............................................................................................841 Leitura e escrita esquemas XML ...........................................................................................................................843 Criando esquemas XML ........................................................................................................................................844 Atravessando esquemas XML................................................................................................................................847 Editar Esquemas XML...........................................................................................................................................849 Incluindo ou importar esquemas XML ..................................................................................................................853 Integração XML com dados relacional e ADO.NET .............................................................................................855 Resolver externos recursos XML nomeados por um URI......................................................................................857 Resolvendo recursos usando o XmlResolver .........................................................................................................857 Fornecer credenciais de autenticação para XmlResolver quando leitura de um arquivo ....................................858 Para criar um objeto XmlReader que usa um XmlSecureResolver .......................................................................860 Codificação de caracteres de nomes XML e conversão de tipos de dados XML...................................................860 Espaços para nomes em um documento XML .......................................................................................................860 Suporte tipo nas classes System.Xml .....................................................................................................................861 Mapear tipos de dados XML para tipos CLR ........................................................................................................861 Observações de implementação de suporte tipo XML...........................................................................................863 Conversão de tipos de dados XML ........................................................................................................................864 SERVIÇOS DA WEB XML NO CÓDIGO GERENCIADO ....................................................................................................866 Introdução à programação serviços XML da Web no código gerenciado ............................................................866 Programação na Web com XML Web Services .....................................................................................................867 Criando XML Web Services em código gerenciado ..............................................................................................867 Acessando XML Web Services no código gerenciado ...........................................................................................869 Criado usando clientes do serviço XML da Web ASP.NET e Serviços XML da Web ...........................................870 Acessar a Página de Ajuda de Serviço ..................................................................................................................878 Acessar a descrição de serviço..............................................................................................................................878 Fornecendo um nome de mensagem para um método de XML Web Service ........................................................883 Criando uma nova transação com um método de XML Web Service....................................................................884 Protegendo Serviços da Web XML Criados Usando ASP.NET.............................................................................895 ACESSO A DADOS (COMO FAZER EM C#) ....................................................................................................................900 Criando os controles para exibir os pedidos para cada cliente (registros filho) ..................................................902 Visão geral sobre como conectar-se a dados no Visual Studio.............................................................................903 Visão Geral do Adaptador de Tabela....................................................................................................................921

Visual C# Consolidado

10

Visão Geral do Preenchimento de DataSets e Consultas de Dados......................................................................927 Visão Geral da Exibição dados .............................................................................................................................936 Ligação de Objeto no Visual Studio ......................................................................................................................962 Visão Geral da Edição de dados em DataSets ......................................................................................................966 Visão geral sobre validação de dados...................................................................................................................967 Visão Geral do Salvar dados.................................................................................................................................972 Introdução ao CONCURRENCY dados em ADO.NET .........................................................................................982 CONCURRENCY pessimista.................................................................................................................................982 CONCURRENCY otimista.....................................................................................................................................983 Última no WINS.....................................................................................................................................................983 A abordagem número versão.................................................................................................................................984 Para adicionar o tratamento de erro para o erro de concorrência ......................................................................989 Elementos de Dados de Interface de Usuário .......................................................................................................994 Adaptadores de Dados do ADO.NET ....................................................................................................................997 Projetos SQL Server ..............................................................................................................................................998 CRIANDO CLASSES (COMO FAZER EM C#) ................................................................................................................1004 COMO: Criar Tipos em Diagramas de Classe ...................................................................................................1004 Criando e Configurando Membros de Tipos .......................................................................................................1005 Criar membros tipo .............................................................................................................................................1005 COMO: Modificar membros de tipo....................................................................................................................1006 COMO: Adicionar um parâmetro a um método..................................................................................................1006 COMO: Abrir a janela Class Details ..................................................................................................................1007 Atalhos de teclado para a janela Detalhes de classe ..........................................................................................1007 Usando o teclado.................................................................................................................................................1008 Observações úteis sobre a janela Class Details ..................................................................................................1009 Exibição de informações somente leitura............................................................................................................1010 Elementos da janela Class Details ......................................................................................................................1011 Linhas membro ....................................................................................................................................................1011 Linhas de parâmetro............................................................................................................................................1012 COMO: Herdar de um Tipo Genérico.................................................................................................................1012 COMO: Definir herança entre tipos....................................................................................................................1013 COMO: Definir associações entre tipos..............................................................................................................1013 COMO: Excluir formas de tipos e código associado de diagramas classe.........................................................1014 COMO: Aplicar atributos personalizados a tipos ou membros de tipo...............................................................1015 COMO: Exibir Herança entre Tipos ...................................................................................................................1015 COMO: Exibir tipos derivados............................................................................................................................1016 COMO: Remover formas de tipos de diagramas de classe .................................................................................1016 COMO: Exibir compartimentos em formas de tipo.............................................................................................1017 COMO: Exibir detalhes do tipo: .........................................................................................................................1018 COMO: Alternar entre notação de membro e notação de associação................................................................1019 COMO: Exibir membros de tipo .........................................................................................................................1019 COMO: Adicionar diagramas de classes a projetos ...........................................................................................1020 COMO: Exibir tipos existentes............................................................................................................................1021 Ententendo um código que você não escreveu ....................................................................................................1022 COMO: Agrupar membros de tipo ......................................................................................................................1022 COMO: Adicionar comentários a diagramas de classe ......................................................................................1022 Personalizando diagramas de classe...................................................................................................................1023 COMO: Copiar elementos de diagrama de classe para um documento do Microsoft Office .............................1024 COMO: Imprimir diagramas de classe ...............................................................................................................1024 COMO: Ignorar membros de tipo .......................................................................................................................1025 COMO: Renomear tipos e membros de tipo........................................................................................................1025 COMO: Mover um membro de tipo de um tipo para outro .................................................................................1026 COMO: Implementar uma interface....................................................................................................................1026 COMO: Implementar uma classe abstrata..........................................................................................................1027 COMO: Extrair para interface (C# somente)......................................................................................................1027 COMO: Reordenar parâmetros (C# somente) ....................................................................................................1027 COMO: Criar um membro ..................................................................................................................................1027 COMO: Implementar um designer para um controle..........................................................................................1029 COMO: Criar e configurar componentes no modo Design.................................................................................1030 Como: Acessar suporte em tempo de design no Windows Forms .......................................................................1036 COMO: Implementar um provedor Extender HelpLabel ....................................................................................1037 COMO: Acessar serviços em tempo de criação ..................................................................................................1041 COMO: Serializar coleções de tipos padrão com o DesignerSerializationVisibilityAttribute............................1048

Visual C# Consolidado

11

Como: Executar inicialização personalizada para controles no modo de design...............................................1049 COMO: Implementar um conversor de tipo ........................................................................................................1050 Para implementar um conversor de tipo simples que pode converter uma seqüência para um ponto................1050 Para implementar um conversor de tipo simples que fornece uma lista drop-down de valores padrão em um navegador Propriedade.......................................................................................................................................1051 Para implementar um conversor tipo que produz Propriedade baseado no construtor-código de inicialização1053 COMO: Implementar um editor UI de tipo .........................................................................................................1054 Como: Estender a aparência e comportamento de controles no modo de design...............................................1055 COMO: Criar um controle de formulários do Windows que tira vantagem de recursos em tempo de criação..1064 COMO: Anexar marcas inteligentes para um componente de formulários do Windows ....................................1071 COMO: Ajustar atributos, eventos e propriedades de um componente no modo Design ...................................1073 PROGRAMAÇÃO DO OFFICE (COMO FAZER EM C#) ...................................................................................................1080 Como: Atualizar soluções das Ferramentas do Visual Studio para o Office ......................................................1080 O Excel Usando Explicações Passo-a-passo.......................................................................................................1081 Coleta de dados usando um formulário do Windows Walkthrough: ...................................................................1081 Para criar um novo projeto .................................................................................................................................1081 Para adicionar um intervalo nomeado para Sheet1............................................................................................1081 Para adicionar um formulário do Windows ........................................................................................................1082 Para exibir o formulário e coletar informações..................................................................................................1082 Para enviar informações para a planilha ...........................................................................................................1083 Para testar sua pasta de trabalho .......................................................................................................................1083 Alterando planilha formatação usando controles CheckBox Walkthrough: .......................................................1083 Para criar um novo projeto .................................................................................................................................1084 Para adicionar três caixas de seleção.................................................................................................................1084 Para adicionar texto a um controle NamedRange ..............................................................................................1085 Exibindo texto em uma caixa de texto em uma planilha usando um botão Walkthrough: ..................................1086 Para testar sua pasta de trabalho .......................................................................................................................1088 Programação contra eventos de um controle NamedRange Walkthrough: ........................................................1088 Walkthrough: vinculação células para várias colunas em uma tabela ...............................................................1099 Criando uma relação mestre / detalhes usando um DataSet em cache Walkthrough:........................................1103 Para criar um novo projeto .................................................................................................................................1104 Armazenar em cache DataSet..............................................................................................................................1105 Para percorrer os registros.................................................................................................................................1106 Para testar o cache de dados ..............................................................................................................................1106 Para adicionar os dados .....................................................................................................................................1107 Para adicionar um gráfico ..................................................................................................................................1108 Para criar um novo projeto .................................................................................................................................1108 Para alterar o nome do controle gráfico.............................................................................................................1109 Para adicionar um controle de usuário...............................................................................................................1109 Para adicionar controles Windows Form ao controle de usuário ......................................................................1109 Para criar um evento e propriedade em um controle de usuário........................................................................1110 Para manipular o evento CheckedChanged dos botões de opção.......................................................................1110 Para adicionar o controle do usuário sua planilha ............................................................................................1111 Para alterar o tipo de gráfico que é exibido na planilha ....................................................................................1111 Para testar sua pasta de trabalho .......................................................................................................................1112 Vinculação de Dados para controles em um painel Ações do Excel Walkthrough:............................................1112 Para criar um novo projeto .................................................................................................................................1113 Para adicionar uma nova fonte de dados para o projeto....................................................................................1113 Para adicionar um NamedRange e um controle ListObject ................................................................................1114 Para adicionar um controle painel Ações ...........................................................................................................1114 Para adicionar controles Windows Forms ligados a dados a um controle painel Ações ...................................1114 Para definir propriedades de vinculação de dados do controle..........................................................................1115 Para mostrar o painel Ações ...............................................................................................................................1115 Para testar seu documento ..................................................................................................................................1115 Implantando um Word ou Solution do Excel usando um manifesto Deployment Walkthrough: .........................1116 Para criar um novo projeto .................................................................................................................................1117 Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1117 Para publicar a solução ......................................................................................................................................1117 Para atualizar o manifesto do aplicativo incorporado........................................................................................1118 Para atualizar a manifesto de implantação.........................................................................................................1119 Para atualizar o manifesto do aplicativo externo ...............................................................................................1119 Para copiar os arquivos de solução para o servidor ..........................................................................................1120 Para conceder confiança total para a pasta de rede...........................................................................................1120

Visual C# Consolidado

12

Para testar a implantação ...................................................................................................................................1120 Implantando um Word ou Solution do Excel usando um arquivo do Windows Installer Walkthrough: .............1121 Para criar um novo projeto .................................................................................................................................1122 Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1122 Para criar um projeto de instalação para a solução...........................................................................................1122 Para adicionar o documento e conjunto ao projeto de instalação......................................................................1123 Para criar um projeto ação personalizada..........................................................................................................1123 Para criar uma ação personalizada que edita o manifesto do aplicativo ...........................................................1124 Para adicionar a saída primária do projeto ação personalizada ao projeto de instalação................................1125 Para testar a instalação ......................................................................................................................................1125 Passo-a-passo: Concedendo e removendo permissões para uma solução do Office ..........................................1126 Para criar um novo projeto .................................................................................................................................1126 Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1126 Para remover um grupo de códigos ....................................................................................................................1127 Para criar um nome forte ....................................................................................................................................1128 Para conceder confiança com base em nome forte .............................................................................................1128 Para testar sua pasta de trabalho .......................................................................................................................1128 O Word Usando Explicações Passo-a-passo.......................................................................................................1129 Walkthrough: Changing Document formatação usando controles CheckBox ....................................................1129 Para criar um novo projeto .................................................................................................................................1129 Para adicionar três caixas de seleção.................................................................................................................1130 Para adicionar texto e um controle indicador.....................................................................................................1130 Para alterar a formatação quando uma caixa de seleção é marcada.................................................................1131 Para testar seu documento ..................................................................................................................................1132 Exibindo texto em uma caixa de texto em um documento usando um botão Walkthrough: ................................1132 Para criar um novo projeto .................................................................................................................................1133 Para adicionar um botão e uma caixa de texto ...................................................................................................1133 Para escrever para a caixa de texto quando o botão é clicado...........................................................................1133 Para testar seu documento ..................................................................................................................................1134 Walkthrough: Criando menus de atalho para indicadores .................................................................................1134 Para criar um novo projeto .................................................................................................................................1135 Para adicionar texto ao seu documento ..............................................................................................................1135 Para adicionar um controle indicador ao seu documento ..................................................................................1135 Para criar o menu de atalho................................................................................................................................1135 Para formatar o texto contido no indicador........................................................................................................1136 Para testar seu documento ..................................................................................................................................1137 Walkthrough: atualizando um gráfico em um documento usando botões de opção............................................1137 Para criar um novo projeto .................................................................................................................................1138 Para adicionar um gráfico ..................................................................................................................................1138 Para adicionar um controle de usuário...............................................................................................................1139 Para adicionar controles Windows Form ao controle de usuário ......................................................................1139 Para adicionar uma referência à 11.0 biblioteca objeto do Graph Microsoft ....................................................1140 Para criar um evento e propriedade em um controle de usuário........................................................................1140 Para manipular o evento CheckedChange dos botões de opção.........................................................................1140 Para adicionar o controle de usuário do documento ..........................................................................................1141 Para alterar o tipo de gráfico que é exibido no documento ................................................................................1141 Para testar seu documento ..................................................................................................................................1142 Vinculação de Dados para controles em um painel Ações do Word Walkthrough:............................................1142 Para criar um novo projeto .................................................................................................................................1143 Para adicionar um controle painel Ações ...........................................................................................................1143 Para adicionar uma nova fonte de dados para o projeto....................................................................................1143 Para adicionar controles Windows Forms ligados a dados a um controle painel Ações ...................................1144 Para carregar o controle com dados...................................................................................................................1145 Para definir propriedades de vinculação de dados do controle..........................................................................1145 Para formatar os títulos de tabela.......................................................................................................................1145 Para criar a tabela ..............................................................................................................................................1146 Para inserir texto em uma tabela do Word..........................................................................................................1146 Para mostrar o painel Ações ...............................................................................................................................1147 Para testar seu documento ..................................................................................................................................1147 Walkthrough: criar uma marca inteligente que converte Temperatures de Fahrenheit para Celsius ................1148 Para criar um novo projeto .................................................................................................................................1148 Para configurar seu projeto ................................................................................................................................1148 Para criar a marca inteligente ............................................................................................................................1149

Visual C# Consolidado

13

Para criar o manipulador de eventos..................................................................................................................1149 Para testar sua pasta de trabalho .......................................................................................................................1150 Implantando um Word ou Solution do Excel usando um manifesto Deployment Walkthrough: .........................1150 Para criar um novo projeto .................................................................................................................................1151 Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1151 Para publicar a solução ......................................................................................................................................1152 Para atualizar o manifesto do aplicativo incorporado........................................................................................1152 Para atualizar a manifesto de implantação.........................................................................................................1153 Para atualizar o manifesto do aplicativo externo ...............................................................................................1153 Para copiar os arquivos de solução para o servidor ..........................................................................................1154 Para conceder confiança total para a pasta de rede...........................................................................................1154 Para testar a implantação ...................................................................................................................................1154 Implantando um Word ou Solution do Excel usando um arquivo do Windows Installer Walkthrough: .............1155 Para criar um novo projeto .................................................................................................................................1156 Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1156 Para criar um projeto de instalação para a solução...........................................................................................1156 Para adicionar o documento e conjunto ao projeto de instalação......................................................................1157 Para criar um projeto ação personalizada..........................................................................................................1157 Para criar uma ação personalizada que edita o manifesto do aplicativo ...........................................................1158 Para adicionar a saída primária do projeto ação personalizada ao projeto de instalação................................1159 Para testar a instalação ......................................................................................................................................1159 Passo-a-passo: Concedendo e removendo permissões para uma solução do Office ..........................................1160 Para criar um novo projeto .................................................................................................................................1160 Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1160 Para remover um grupo de códigos ....................................................................................................................1161 Para criar um nome forte ....................................................................................................................................1162 Para conceder confiança com base em nome forte .............................................................................................1162 Para testar sua pasta de trabalho .......................................................................................................................1162 COMO: Adicionar Controles a Documentos do Office.......................................................................................1162 Para arrastar um Windows Forms controle para o documento..........................................................................1163 Para desenhar um Windows Forms controle sobre o documento .......................................................................1163 Para adicionar um controle Windows Forms para o documento clicando uma única vez sobre o controle ......1164 Para adicionar um controle Windows Forms para o documento clicando duas vezes no controle ....................1164 Para adicionar um controle Windows Forms para o documento, pressionando a tecla ENTER........................1164 Para adicionar um Windows Forms controlar programaticamente ...................................................................1165 COMO: Executar Cálculos do Excel por Programação .....................................................................................1165 Para executar cálculos em um controle NamedRange ........................................................................................1165 Executar cálculos para o aplicativo inteiro ........................................................................................................1165 Para executar cálculos em todas as pastas de trabalho abertas.........................................................................1165 Como: Criar menus do Office programaticamente .............................................................................................1166 COMO: Criar Barras de Ferramentas do Office por Programação...................................................................1167 DISPOSITIVOS INTELIGENTES ....................................................................................................................................1168 O que há de novo em projetos Smart Device.......................................................................................................1168 O que há de novo no desenvolvimento visual aplicativos dispositivos C++.......................................................1168 Destino vários sistemas operacionais .................................................................................................................1168 Sistema do projeto ...............................................................................................................................................1168 O IntelliSense ......................................................................................................................................................1168 Modo misto Solutions ..........................................................................................................................................1168 Instalar do aplicativo ..........................................................................................................................................1168 Aplicativos personalizados e assistentes de classe..............................................................................................1168 Editor de recursos ...............................................................................................................................................1169 ATL ......................................................................................................................................................................1169 MFC ....................................................................................................................................................................1170 O que há de novo no Managed projetos de dispositivo .......................................................................................1170 Como Iniciar o Emulador de Dispositivo no Visual Studio.................................................................................1171 Visão geral do acesso de dados (projetos do dispositivo gerenciado) ................................................................1172 Visão geral Solutions do dispositivo de embalagem ...........................................................................................1173 Alternar plataformas em projetos de dispositivo.................................................................................................1174 Ferramentas Remotas para Projetos de Dispositivos .........................................................................................1174 Visão geral sobre segurança (dispositivos).........................................................................................................1175 Seleção método de conexão.................................................................................................................................1176 Atualizando Projetos Criados com Ferramentas Anterior..................................................................................1178 Selecionando uma Linguagem de Desenvolvimento............................................................................................1179

Visual C# Consolidado

14

Programação para Dispositivos usando o .NET Compact Framework ..............................................................1182 Referência do .NET Compact Framework para Projetos de Dispositivos ..........................................................1183 Gerenciando Trechos de Código em Projetos Dispositivos ................................................................................1186 Diferenças entre depuradores de dispositivos e de desktop ................................................................................1194 IMPLANTAÇÃO (COMO FAZER EM C#) .......................................................................................................................1235

Visual C# Consolidado

15

VISUAL C# Microsoft Visual C# 2005, pronunciado C sharp, é uma linguagem de programação projetada para criar uma ampla variedade de aplicativos executados no .NET Framework. C# é simples, poderoso, com segurança de tipos, e orientada a objetos. Com suas muitas inovações, C# permite o desenvolvimento rápido de aplicativos mantendo a expressividade e elegância das linguagens do estilo C. Visual Studio oferece suporte ao Visual C# com um editor de códigos completo, modelos de projeto, designers, assistentes de código, depurador poderoso e de fácil uso, e outras ferramentas. A biblioteca de classes do .NET Framework fornece acesso a uma grande variedade de serviços do sistema operacional e outras classes úteis, e bem estruturadas que aceleram o ciclo de desenvolvimento significativamente.

Nesta seção Guia de Introdução ao Visual C# Apresenta os recursos do C# 2.0 para programadores novos para a linguagem ou novos para o Visual Studio, e fornece um roadmap para encontrar ajuda no Visual Studio. Isso também está localizado nas páginas "Como Fazer".

Usando o Visual C# IDE Apresenta o ambiente de desenvolvimento do Visual C#.

Escrevendo aplicativos com Visual C# Fornece uma orientação de alto nível abrangendo tarefas comuns de programação usando C# e o .NET Framework, com links para a documentação mais detalhada.

Migrando para o Visual C# Compara a linguagem C# com Java e C++ e descreve como usar o Java Language Conversion Assistant para converter aplicativos Java e Visual J++ para Visual C#.

Guia de programação C # Fornece informações e exemplos práticos sobre como usar construções de linguagem C#.

Referência C# Fornece informações de referência detalhadas em conceitos de programação C#, palavras-chave, tipos, operadores, atributos, diretivas de pré-processador, opções de compilador, e erro de compilador e avisos.

Especificação da linguagem C# Links para a versão mais recente das especificações C# no formato Microsoft Word.

Exemplos de Visual C# Exemplo de código fonte que demonstram como programar usando Visual C#.

Visual C# Consolidado

16

GUIA DE INTRODUÇÃO AO VISUAL C# Os tópicos a seguir ajudam a iniciar o desenvolvimento de aplicativos usando o Microsoft Visual C# 2005. Esses tópicos também lhe introduzirão a muitos novos recursos no Microsoft Visual Studio 2005 como versão 2.0 da linguagem C#. Nesta seção Guia da documentação do Visual C# Fornece uma orientação de alto nível sobre o conteúdo da documentação Visual C#. Introdução à linguagem C# e ao Framework .NET Fornece uma visão geral sobre a linguagem C# e a plataforma .NET. O Que Há de Novo no Visual C-# 2005 O que há de novo no Microsoft Visual C# 2005. O Que Há de Novo na Linguagem e Compilador C# 2.0 O que há de novo na versão 2.0 do C#. Atualizando Aplicativos Visual C# para Visual Studio 2005 Atualizando seus projetos existentes para o Microsoft Visual Studio 2005. Criando Seu Primeiro Aplicativo C# Escrevendo, compilando e executando um simples aplicativo C#. Usando Starter Kits C# Usando os Starter Kits C#. Recursos de ajuda adicionais (Visual C#) Links para outros recursos de ajuda. Como Fazer em C# Links para tópicos que mostram como executar uma variedade de tarefas específicas.

Guia da Documentação do Visual C# A documentação do Microsoft Visual C# 2005 contém informações que são específicas para a linguagem C#, como palavras-chave, opções de compilador, mensagens de erro e conceitos de programação. Esta documentação também oferece uma visão geral de como usar o ambiente de desenvolvimento integrado (IDE). Além disso, existem muitos links para obter ajuda detalhada sobre classes .NET Framework, desenvolvimento da Web do ASP.NET, depuração, programação de banco de dados SQL e muito mais. O diagrama a seguir fornece uma exibição dos conceitos do conteúdo da documentação do Visual C# e o relacionamento deste conteúdo com outras seções relevantes da documentação do Visual Studio e a MSDN on-line.

Visual C# Consolidado

17

Introdução à linguagem C# e ao .NET Framework C# é uma linguagem elegante orientada a objetos e fortemente tipada que permite aos desenvolvedores criar uma ampla variedade de aplicativos seguros e eficientes que são executados sob o .NET Framework. Você pode usar C# para criar aplicativos clientes tradicionais do Windows , XML Web services, componentes distribuídos, aplicativos cliente-servidor, aplicativos de banco de dados, e muito, muito mais. Microsoft Visual C# 2005 fornece um editor de código avançado, designers de interface de usuário convenientes, depurador integrado, e muitas outras ferramentas para facilitar o rápido desenvolvimento de aplicativos com base na versão 2.0 da linguagem C# e do .NET Framework. Observação A documentação Visual C# presume que você tenha uma compreensão dos conceitos básicos existentes de programação. Se você for um completo principiante, convém explorar Visual C# Express Edition, que está disponível na Web. Você também pode aproveitar qualquer um dos diversos livros excelentes e recursos da Web em C# para aprender técnicas de prática de programação. Linguagem C# A sintaxe C# é altamente expressiva, mas com menos de 90 palavras-chave, também é simples e fácil para aprender. A sintaxe do C# utilizando chaves como marcador de blocos será instantaneamente reconhecível para qualquer pessoa familiarizada com C, C++ ou Java. Os desenvolvedores que conhecem qualquer uma dessas linguagens são normalmente capazes de começar a trabalhar produtivamente em C# dentro de muito pouco tempo. A sintaxe C# simplifica muitas das complexidades de C++ enquanto fornece recursos poderosos como tipos de valor anulável, enumerações, delegações, métodos anônimos e acesso direto à memória, que não foram localizados em Java. C# também oferece suporte a métodos e tipos genéricos, que fornecem aumento de segurança e desempenho, e iteradores, que permitem implementadores das classes de coleção definirem comportamentos personalizados da iteração que são simples para usar pelo código do cliente.

Visual C# Consolidado

18

Como uma linguagem orientada a objetos, C# suporta os conceitos de encapsulamento, herança e polimorfismo. Todas as variáveis e métodos, incluindo o método Main, ponto de entrada do aplicativo, são encapsulados em definições da classe. Uma classe pode herdar diretamente de uma classe pai, mas ela pode implementar qualquer número de interfaces. Métodos que substituem métodos virtuais em uma classe pai exigem a palavra-chave override como uma forma para evitar redefinição acidental. No C#, uma estrutura é como uma classe simplificada; ele é um tipo alocado na pilha que pode implementar interfaces mas não tem suporte a herança. Além desses princípios orientados a objetos, C# facilita o desenvolvimento de componentes de software através de vários construtores inovadores da linguagem, incluindo: •

Assinaturas de métodos encapsulados chamadas delegações, que permitem notificações de eventos fortemente tipados.

•

Propriedades, que servem como accessadores de variáveis membros privadas.

•

Atributos, que fornecem metadados declarativos sobre tipos no tempo de execução.

•

Comentários internos da documentação XML.

Se você precisar interagir com outro software Windows como objetos COM ou DLLs nativas Win32, você pode fazer isso em C# através de um processo denominado "Interoperabilidade". Interoperabilidade permite que programas C# façam praticamente tudo que um aplicativo C++ nativo pode fazer. C# também suporta ponteiros e o conceito de código "inseguro" para os casos no qual o acesso direto a memória é absolutamente essencial. O processo de compilação C# é simples comparado ao C e C++ e mais flexível do que em Java. Não há nenhum arquivo cabeçalho separado, e nenhum requisito de que métodos e tipos sejam declarados em uma ordem específica. Um arquivo fonte C# pode definir qualquer número de classes, estruturas, interfaces, e eventos. Arquitetura da plataforma .NET Framework Programas C# são executados no .NET Framework, um componente integrante do Windows que inclui um sistema de execução virtual chamado de Common Language Runtime (CLR) e um conjunto unificado de bibliotecas de classe. O CLR é implementação comercial da Microsoft do Common Language Infrastructure (CLI), um padrão internacional que é a base para criar ambientes de execução e desenvolvimento nos quais linguagens e bibliotecas trabalham perfeitamente juntas. Código fonte escrito em C# é compilado em uma linguagem intermediária (IL) que está em conformidade com a especificação CLI. O código IL, juntamente com recursos como bitmaps e seqüências de caracteres, é armazenado em disco em um arquivo executável chamado de assembly, normalmente com uma extensão .exe ou .dll. Um assembly contém um manifesto que fornece informações sobre tipos do assembly, versão, cultura, e requisitos de segurança. Quando o programa C# é executado, o módulo (assembly) é carregado no CLR, que pode levar a várias ações com base nas informações no manifesto. Em seguida, se os requisitos de segurança forem atendidos, o CLR executa a compilação Just-In-Time (JIT) para converter o código IL em instruções nativas da máquina. O CLR também oferece outros serviços relacionados a coleta de lixo automática, tratamento de exceção, e gerenciamento de recursos. Código que é executado pelo CLR é as vezes conhecido como "código gerenciado", em contraste com "código não gerenciado" que é compilado em linguagem de máquina nativa que atinge um sistema específico. O diagrama a seguir ilustra os relacionamentos entre o tempo de compilação e o tempo de execução dos arquivos de código fonte C#, as bibliotecas de classes base, módulos (assemblies), e o CLR.

Visual C# Consolidado

19

A interoperabilidade da linguagem é um recurso chave do .NET Framework. Por estar em conformidade com o Common Type Specification (CTS), o código IL produzido pelo compilador C# pode interagir com código que foi gerado a partir das versões .NET do Visual Basic, Visual C++, Visual J#, ou qualquer uma das outras mais de 20 linguagens CTS-Compliant. Um conjunto único pode conter vários módulos escritos em linguagens .NET diferentes, e os tipos podem se referenciar como se eles fossem escritos na mesma linguagem. Além dos serviços de tempo de execução, o .NET Framework também inclui uma biblioteca abrangente com mais de 4000 classes organizadas em namespaces que fornecem uma variedade de funcionalidades úteis para tudo desde entrada e saída de arquivo até manipulação de seqüência para análise XML e controles de Windows Forms. Uma aplicação C# típica usa amplamente a biblioteca de classe do .NET Framework para manipular tarefas comuns de "conexões internas".

O que há de novo no Visual C# 2005 O Microsoft Visual C# 2005 inclui novos recursos nas áreas a seguir: •

Linguagem e Compilador

•

Editor de códigos

•

Ambiente de desenvolvimento

•

Documentação e especificação de linguagem

•

Depuração

Linguagem e Compilador A linguagem C# agora suporta tipos genérico, iteradores e tipos parciais. A versão mais recente do compilador C# também inclui novos recursos e opções. Para mais informações, consulte O que há de novo na Linguagem e Compilador C# 2.0. Editor de códigos O Editor de códigos contém os seguintes recursos novos para Visual C# 2005.

Trechos de código Visual C# Consolidado

20

Trechos de códigos aumentam a velocidade de entrada de códigos de construção comuns fornecendo um modelo que pode ser preenchido. Trechos são armazenados como arquivos XML que podem ser facilmente editados e personalizados. •

Trechos de códigos (C#)

•

COMO: Usar trechos de código (C#)

•

COMO: Usar trechos de código circunscritos

Refatoração Ferramentas de refactoração podem automaticamente reestruturar seu código fonte, por exemplo, promovendo as variáveis locais para parâmetros ou convertendo um bloco de código em um método. •

COMO: Promover variável local para parâmetro

•

Extrair o método

•

Encapsular o campo

•

Extrair a interface

•

Renomear

•

Remover parâmetros

•

Reordenar parâmetros

Ambiente de Desenvolvimento O ambiente de desenvolvimento inclui os seguintes aperfeiçoamentos para Visual C# 2005.

O IntelliSense O IntelliSense foi aprimorado com os novos recursos a seguir: •

A lista de conclusão de List Members aparece automaticamente quando você volta com o cursor para um operador de escopo que precede um objeto, ou quando você desfaz a ação de conclusão.

•

Quando você escreve código de tratamento de erros, o Membros lista o ajuda a descobrir qual exceção atrair filtrando membros irrelevantes da lista de conclusão em uma cláusula catch.

•

Quando você precisa inserir código padronizado, o Automatic Code Generation agora permite que você determine que o IntelliSense insira o código para você.

•

IntelliSense está disponível ao criar aplicativos da Web.

Class Designer O Class Designer é um novo editor que exibe graficamente classes e tipos e permite que os métodos sejam adicionados ou modificados. Também é possível usar ferramentas de refatoração a partir da janela Class Designer. •

Consulte Projetando e exibindo classes e tipos.

Banco de Testes de Objeto O banco de testes de objeto é projetado para teste simples a nível de objeto. Permite criar uma instância de um objeto e chamar seus métodos. •

Consulte Banco de Testes de Objeto.

Implantação ClickOnce A implantação ClickOnce permite que você publique aplicativos do Windows em um servidor Web ou em compartilhamento de arquivos de rede para instalações simplificadas.

Visual C# Consolidado

21

•

Consulte Implantação ClickOnce.

Suporte a Ferramentas para Assemblies Fortemente Nomeados A caixa de diálogo Project Properties foi reprojetada, e agora inclui suporte para assinatura a assemblies. •

Consulte Propriedades do Projeto.

Assistentes de Código Os assistentes código a seguir estão agora obsoletos: •

Assistente para o método C#

•

Assistente para a propriedade C#

•

Assistente para o campo C#

•

Assistente para o indexador C#

Documentação e Especificação de Linguagem Amplamente a documentação de referência do C# tem sido regravada para fornecer informações mais completas para perguntas comuns assim como avançadas de uso que os desenvolvedores podem encontrar ao criar aplicativos em C#. O especificador de linguagem do C# está mais integrado para o ambiente de Ajuda, mas é fornecido em dois arquivos .doc. Esses arquivos são instalados por padrão em \\Microsoft Visual Studio 8\vcsharp\specifications\1033\. As versões mais atualizadas podem ser baixadas na Central de Desenvolvimento do C# no MSDN. Para mais informações, consulte Especificação de Linguagem do C#. Melhorias na Depuração Específica do C# Novos recursos, incluindo Edit e Continue, foram adicionados para auxiliar o desenvolvedor C#.

O que há de novo na C# 2.0 idioma e Compiler Com o lançamento do Visual Studio 2005, a linguagem C# foi atualizada para versão 2.0, que oferece suporte os seguintes recursos novos: Tipos genéricos Tipos genéricos são adicionados ao idioma para ativar os programadores para atingir um nível alto de reutilização e desempenho avançado para classes coleção. Tipos genéricos podem diferir somente por aridade. Parâmetros também podem ser forçados a ser tipos específicos. Para obter mais informações, consulte Parâmetros genéricos tipo. Iteradores Iterators facilitam para ditar um foreach loop como será iterar sobre uma coleção o conteúdo. Classes parciais Definições de tipo parcial permitem que um tipo simples, a ser dividida em vários arquivos, como uma classe,. O designer visual studio utiliza esse recurso para separar seu código gerado do código do usuário. Tipos anulável Tipos anuláveis permitem que uma variável para conter um valor que é indefinido. Tipos anuláveis são úteis quando trabalhar com bancos de dados e outras estruturas de dados que podem conter elementos que contêm sem valores específicos. Métodos anônimo

Visual C# Consolidado

22

Agora é possível para passar um bloco de código como um parâmetro. Qualquer Lugar um representante é esperado, um bloco de código poderá ser usado: não é necessário para definir um novo método. Qualificador alias Namespace O qualificador alias espaço para nome. proporciona mais controle sobre acessar membros espaço para nome (::) O global:: alias permite acesso a raiz que pode estar ocultas por uma entidade em seu código. Classes estáticas Classes estáticas são uma maneira segura e conveniente de declarar uma classe que contém métodos estáticos que não podem ser instanciados. Em C# versão 1.2 você seria tenha definido o construtor de classe como particular para impedir que a classe sendo instanciado. Alias assembly externo Referência versões diferentes do mesmo componente contidos no mesmo conjunto com esse uso expandido de palavra-chave extern. Propriedade acessibilidade Accessor Do get agora é possível para definir diferentes níveis de acessibilidade para e set assessores em Propriedades. Covariância e Contravariance em representantes O método passado para um representante agora podem ter maior flexibilidade no seu tipo de retorno e parâmetros. HOW TO: Declare, Instantiate, e usar um representante Método conversão de grupo fornece uma sintaxe simplificada para declarar representantes. Buffers tamanho fixo Em um bloco código desprotegido, agora é possível para declarar estruturas de tamanho fixo com matrizes incorporados. Conjuntos de amigo Conjuntos podem fornecer acesso a tipos não-públicos para outros conjuntos. Controle de aviso embutido A #pragma diretiva de aviso pode ser usada para desativar e ativar determinados avisos do compilador. volátil Agora pode ser aplicada a IntPtr palavra-chave volatile e UIntPtr. O compilador C# apresenta os seguintes adições e alterações para esta versão: Opção /errorreport Pode ser usado para relatar erros de compilador interno à Microsoft através da Internet. Opção /incremental Foi removido. e /keycontainer/KeyFile Opções Oferecer suporte à especificação chaves criptográficas. Opção /langversion Pode ser usado para especificar compatibilidade com uma versão específica do idioma.

Visual C# Consolidado

23

Opção /linkresource Contém opções adicionais. Opção /moduleassemblyname Permite que você se criar um.netmodule tipos de arquivo e acesso não-públicos em um conjunto existente. Opção /PDB Especifica o nome e local do arquivo.pdb. Opção /Platform Permite que você para arquiteturas Family (IPF) Itanium e x 64 de destino. Aviso # pragma Usado para desativar e ativar individuais avisos no código.

Atualizando Aplicativos Visual C# para Visual Studio 2005 Quando você abre um arquivo de projeto ou de solução criado por uma versão anterior do Visual Studio, o Assistente para Atualização guia você através do processo de converter seu projeto para Visual Studio 2005. O Assistente para Atualização executa várias tarefas, entre elas: cria novas propriedades e atributos e exclui os obsoletos, mas como a verificação de erros tornou-se mais rígida, você pode encontrar novos erros ou mensagens de aviso que não foram produzidos pela versão anterior do compilador. Assim, a etapa final na atualização de um aplicativo existente é fazer as alterações de código necessárias para resolver quaisquer novos erros. Freqüentemente, um código que produzia uma certa mensagem nas versões anteriores do compilador de C# produz uma mensagem diferente na versão atual. Normalmente, isso se deve ao fato de que uma mensagem geral foi substituída por uma mais específica. Como nenhuma alteração no código é necessária, essas diferenças não foram documentadas. A seguir, estão as novas mensagens que o 'Assistente para Atualização' gera devido à verificação de erros mais rigorosa. Novas Mensagem de Erro e de Aviso

CS0121: Ambiguous call (Chamada ambígua) Devido a uma conversão implícita, o compilador não foi capaz de chamar uma implementação específica de um método sobrecarregado. Você pode resolver este erro das seguintes formas: •

Especificar os parâmetros do método de tal forma que a conversão implícita não exista.

•

Remover todos as outras implementações do método.

•

Converter para um tipo apropriado antes de chamar o método.

CS0122: Method inaccessible due to its protection level (Método inacessível devido ao seu nível de proteção) Você poderá receber este erro ao fazer referência um tipo em um assembly compilado pelo C++ que foi compilado com a opção de compilador /d1PrivateNativeTypes. Este erro ocorre porque, na versão atual, um assembly C++ produz uma assinatura que usa um tipo que não está marcado como público. Você pode contornar esse problema usando a opção /test:AllowBadRetTypeAccess do compilador. Esta opção será removida quando este recurso foi corrigido.

CS0429: Unreachable expression code detected (Expressão de código inatingível detectada)

Visual C# Consolidado

24

Este erro ocorre sempre que parte de uma expressão em seu código é inatingível. Por exemplo, a condição false && myTest() casa com esse critério, pois o método myTest() nunca será executado já que o lado esquerdo da operação && é sempre falso. Para corrigir isso, refaça o teste lógico para eliminar o código inacessível.

CS0441: A class cannot be both static and sealed (Uma classe não pode ser ao mesmo tempo estática e lacrada) Todas as classes estáticas são também classes lacradas. A especificação de linguagem C# proíbe a especificação de ambos os modificadores em uma classe e o compilador agora relata isso como um erro. Para corrigir esse erro, remova sealed da classe.

CS1699: Warning on use of assembly signing attributes (Alerta no uso de atributos de assinatura de assembly) Os atributos de assembly que especificam assinatura foram movidos do código para opções do compilador. Usar os atributos AssemblyKeyFile ou AssemblyKeyName no código produz este aviso. Em vez desses atributos, você deve usar as opções de compilador a seguir: •

Use a opção de compilador /keyfile (Especifica um Arquivo Chave de Nome Forte) (Opções do Compilador de C#) ao invés do atributo AssemblyKeyFile, e use /keycontainer (Especifica um Contêiner de Chave de Nome Forte) (Opções do Compilador de C#) ao invés de AssemblyKeyName.

Não mudar para as opções de linha de comando não pode dificultar os diagnósticos do compilador quando friend assemblies estiverem sendo usados. Se você estiver usando /warnaserror (Trata Aviso como Erros) (Opção do Compilador de C#), você pode converter de volta para um aviso adicionando /warnaserror-:1699 a linha de comando do seu compilador. Se necessário, você pode desativar o aviso usando /nowarn:1699.

Incremental compilation removed (Compilação incremental removida) A opção /incremental do compilador foi removida. O recurso de Edição e Continuação substitui essa funcionalidade.

Criando Seu Primeiro Aplicativo C# Somente leva um minuto para criar um aplicativo C#. Siga estas etapas para criar um programa que abre uma janela e reage a um pressionamento de botão. Procedimentos

Para criar um aplicativo C# 1. 2.

No menu File, aponte para New, e em seguida, clique em Project Verifique se o modelo Windows Application está selecionado, no campo Name, digite MyProject , e clique em OK. Você verá um Windows Form no designer de Windows Forms. Essa é a interface de usuário para seu aplicativo.

3.

No menu View, clique em Toolbox para tornar a lista de controles visível.

4.

Expanda a lista Common Controls, e arraste o controle Label para seu formulário.

5.

Também da lista Common Controls, arraste um botão para o formulário, próximo ao Label.

Visual C# Consolidado

25

6.

Clique duas vezes no novo botão para abrir o Editor de Código. Visual C# inseriu um método chamado button1_Click que é executado quando o botão for clicado.

7.

Altere o método para ter esta aparência: private void button1_Click(object sender, EventArgs e) {label1.Text = "Hello, World!";}

8.

Pressione F5 para compilar e executar o aplicativo. Quando você clicar no botão, é exibida uma mensagem de texto. Parabéns! Você acabou de escrever seu primeiro aplicativo C#.

Usando Starter Kits C# Um Starter Kit é um aplicativo completo e independente pronto para você carregar e compilar. Um Starter Kit vem com sua própria documentação, incluindo descrições de técnicas de programação, e sugestões para como ele pode ser personalizado. Starter Kit é uma maneira excelente de ver um aplicativo C# que funciona em ação. Para carregar e compilar um Starter Kit Visual C# 1.

No menu File, clique em New Project. A caixa de diálogo New Project será exibida. Esta caixa de diálogo lista os diferentes tipos de aplicativos padrão que Visual C# pode criar.

2.

Selecione um tipo de aplicativo Starter Kit, e clique em OK. O Starter Kit é carregado no Visual C#.

3.

Para compilar e iniciar o projeto Starter Kit, pressione F5.

Recursos de Ajuda Adicionais (Visual C#) Os sites e grupos de notícias a seguir lhe ajudarão a encontrar respostas para problemas comuns e não tão comuns. Recursos Microsoft Os sites a seguir são mantidos pela Microsoft e hospedam artigos e grupos de discussão sobre tópicos de interesse para os desenvolvedores C#.

Na Web A Ajuda do Microsoft e Suporte Fornece acesso a artigos da KB, downloads e atualizações, WebCasts de suporte e outros serviços. O Microsoft Visual C# Developer Center Fornece exemplos de código, informações sobre atualização, e conteúdo técnico. Grupos de discussão MSDN Fornece uma maneira para conectar-se a uma comunidade de especialistas de todo o mundo.

Fóruns Forums técnico da Microsoft Fóruns discussão baseados na Web para muitas tecnologias Microsoft incluindo C# e o Framework .NET.

Grupos de notícias microsoft.public.dotnet.languages.csharp Fornece um fórum para perguntas e discussão geral sobre Visual C#.

Visual C# Consolidado

26

microsoft.public.vsnet.general Fornece um fórum para perguntas e problemas no Visual Studio. microsoft.public.vsnet.IDE Fornece um fórum para perguntas sobre como trabalhar no ambiente Visual Studio. microsoft.public.vsnet.documentation Fornece um fórum para perguntas e problemas na documentação Visual C#. Recursos de terceiros O site do MSDN fornece informações sobre sites de terceiros e grupos de notícias de atual interesse. Para a lista mais atual dos recursos disponíveis, consulte o Site MSDN Community.

Como Fazer em C# Como Fazer é sua porta de entrada para tópicos-chave baseados em tarefas sobre programação e desenvolvimento de aplicativos em C#. As categorias essenciais sobre o que você pode fazer com C# estão listadas neste tópico. Os links fornecem referências para páginas de ajuda importantes baseadas em procedimento. A Linguagem C# Especificação da Linguagem C# ... Threading… Genéricos... Trechos de Código… Exemplos… mais O Framework .NET Entrada e Saída em Arquivos… Strings… Coleções… Serialização… Componentes… Módulos (assemblies) e Domínios de Aplicativo… mais Aplicativos do Windows Criando Aplicativos do Windows… Controles…Windows Forms… Desenhando… mais Páginas Web e Web Services Pages Web do ASP.NET… XML Web Services… mais Depuração Usando o Depurador VS… Classe Trace .Framework NET… Depuração de Transações SQL… mais Accesso a Dados Conectando a Fontes de Dados… O SQL Server... Vinculação de Dados… mais Criando Classes Class Designer... Trabalhando com Classes e Outros Tipos... Criando e Modificando Membros-tipo... Linhas-mestras para a Criação de Bibliotecas de Classes… mais Segurança Segurança no Acesso ao Código… Práticas Recomendadas de Política de Segurança… Conjuntos de Permissões… mais Programação do Office Programação do Office… Controles… Word… Excel… mais Dispositivos Inteligentes O que há de novo em Projetos para Dispositivos Inteligentes... Programação para Dispositivos Inteligentes... Depuração em Dispositivos Inteligentes... mais Implantação

Visual C# Consolidado

27

ClickOnce… O Windows Installer Recursos adicionais Os seguintes sites requerem uma conexão com a Internet. Visual Studio 2005 Developer Center Contém vários artigos e recursos sobre o desenvolvimento de aplicativos usando o Visual Studio 2005. Este site é atualizado regularmente com novo conteúdo. Visual C# Developer Center Contém vários artigos e recursos sobre desenvolvimento de aplicativos C#. Este site é atualizado regularmente com novo conteúdo. Microsoft .NET Framework Developer Center Contém vários artigos e recursos em desenvolvimento e depuração de aplicativos do Framework .NET. Este site é atualizado regularmente com novo conteúdo.

Visual C# Consolidado

28

USANDO O IDE DO VISUAL C# Esta seção lhe apresenta ao ambiente de desenvolvimento integrado (IDE) do Visual C# e descreve como ele é usado em todas as fases do ciclo de desenvolvimento, indo desde como configurar um projeto até distribuir o aplicativo concluído para usuários finais.

Introdução à IDE (Visual C#) O ambiente de desenvolvimento integrado (IDE) do Visual C# é uma coleção de ferramentas de desenvolvimento expostas por meio de uma interface de usuário comum. Algumas das ferramentas são compartilhados com outras linguagens do Visual Studio, e algumas, como o compilador C#, são exclusivas para Visual C#. A documentação nesta seção fornece uma visão geral de como usar as ferramentas mais importantes do Visual C# enquanto você trabalha na IDE em várias fases do processo de desenvolvimento. Observação Se você estiver desenvolvendo um aplicativo ASP.NET 2.0, você irá usar a IDE Visual Web Developer, que é uma parte totalmente integrada do Visual Studio 2005. Entretanto, se suas páginas code-behind estiverem em Visual C#, você estará utilizando o Editor de Códigos do Visual C# dentro do Visual Web Developer. Portanto, alguns tópicos nesta seção, como Projetando uma interface de usuário (Visual C#), talvez não sejam completamente aplicáveis a aplicativos da Web. Ferramentas Visual C# A seguir estão as mais importantes ferramentas e janelas no Visual C#. As janelas para a maioria dessas ferramentas podem ser abertas a partir do menu View. •

O Editor de Códigos, para escrever código fonte.

•

O compilador C#, para converter código fonte C# em um programa executável.

•

O depurador do Visual Studio, para testar seu programa.

•

O Toolbox (Caixa de Ferramentas) e o Designer, para o desenvolvimento rápido de interfaces de usuário usando o mouse.

•

Solution Explorer (Gerenciador de Soluções) para exibir e gerenciar arquivos de projeto e configurações.

•

Designer de Projeto, para configurar opções do compilador, caminhos de implantação, recursos, e mais.

•

Modo de Exibição de Classe, para navegar através de código fonte de acordo com tipos, não arquivos.

•

Janela Properties (Janela de Propriedades), para configurar propriedades e eventos nos controles na sua interface de usuário.

•

Pesquisador de objetos para exibir os métodos e as classes disponíveis em bibliotecas de vínculo dinâmico incluindo assemblies do .NET Framework e objetos COM.

•

Gerenciador de Documento, para navegação e pesquisa de documentação do produto em sua máquina local e na Internet.

Como a IDE expõe as ferramentas Você interage com as ferramentas através de janelas, menus, páginas de propriedades, e assistentes na IDE. A IDE básica tem mais ou menos esta aparência:

Visual C# Consolidado

29

Rapidamente você pode acessar qualquer janela de ferramenta aberta ou arquivos, pressionando CTRL + TAB. Para mais informações, consulte Navegando e procurando (Visual C#).

Janelas do Editor e do Windows Form Designer A janela principal é usada pelo Editor de Códigos e pelo Windows Forms Designer. Você pode alternar entre o modo Código e o modo Design pelo pressionamento da tecla F7, ou clicando em Code ou Designer no menu View. Enquanto estiver no modo Design, você pode arrastar controles da Caixa de Ferramentas para a janela , que você poderá tornar visível clicando na guia Toolbox na margem esquerda. Para obter mais informações sobre o Editor de Códigos, consulte Editando Código (Visual C#). Para obter mais informações sobre o Windows Forms Designer, consulte O Windows Forms Designer. A janela Properties no canto inferior direito é povoada somente no modo Design. Ela permite a você definir propriedades e ligar eventos a controles de interface de usuário como botões, caixas de texto, e assim por diante. Quando você define esta janela como Ocultar Automaticamente, ela será colapsada na margem direita sempre que você alternar para o Modo Código. Para obter mais informações sobre a janela Properties e o Designer, consulte Projetando uma interface de usuário (Visual C#).

Gerenciador de Soluções e Designer de Projeto A janela na parte superior direita é a do Gerenciador de Soluções, que mostra todos os arquivos em seu projeto em um modo de exibição de árvore hierárquica. Quando você usa o menu Project para adicionar novos arquivos ao seu projeto, você os verá refletidos no Gerenciador de Soluções. Além dos arquivos, o Gerenciador de Soluções também exibe as configurações do projeto, e referências a bibliotecas externas exigidas pelo seu aplicativo. As páginas de propriedades do Designer de Projeto são acessadas com o botão direito do mouse no nó Properties no Gerenciador de Soluções, e clicando Open. Use essas páginas para modificar opções de compilação, requisitos de segurança, detalhes de implantação, e muitas outras propriedades do projeto. Para obter mais informações sobre o Gerenciador de Soluções e o Designer de Projeto, consulte Criando um Projeto (Visual C#).

Janela do Compilador, do Depurador, e de Lista de Erros O compilador C# não tem nenhuma janela porque ele é não uma ferramenta interativa, mas você pode definir opções do compilador no Designer de Projeto. Quando você clica em Build no menu Build , o compilador C# é chamado pela IDE. Se a compilação for bem sucedida, o painel de status exibe uma mensagem compilação bem sucedida. Se houver erros de compilação, a janela Error List aparece abaixo da janela Editor/Designer com uma lista de erros. Dê um duplo clique em um erro para ir para a linha com problema no seu código fonte. Pressione F1 para consultar a documentação de Ajuda para o erro realçado. O Depurador tem várias janelas que exibem valores de variáveis e informações de tipo quando o seu aplicativo está sendo executado. Você pode usar a janela do Editor de Códigos durante a depuração para especificar uma linha na qual pausar a execução, e depurar o código linha a linha. Para mais informações, consulte Criando e Depurando (Visual C#).

Visual C# Consolidado

30

Personalizando a IDE Toda janela no Visual C# pode ser feita ancorável ou flutuante, oculta ou visível, ou pode ser movida para novos locais. Para alterar o comportamento de uma janela, clique nos ícones da seta para baixo ou push-pin na barra de título e selecione dentre as opções disponíveis. Para mover uma janela ancorada para um novo local ancorado, arraste a barra de título até que os ícones de conta-gotas da janela apareçam. Mantendo pressionado o botão esquerdo do mouse, mova o ponteiro do mouse sobre o ícone no novo local. Posicione o ponteiro sobre os ícones esquerda, direita, superior ou inferior para encaixar a janela no lado especificado. Posicione o ponteiro sobre o ícone meio para tornar a janela uma janela com guias. Como você posiciona o ponteiro, um retângulo azul semi-transparente aparece, o qual indica onde a janela será ancorada no novo local.

Você pode personalizar muitos outros aspectos da IDE clicando em Options no menu Tools. Para mais informações, consulte Opções de Caixa de Diálogo do Visual Studio.

Criando um Projeto (Visual C#) Quando você estiver pronto para iniciar a codificação, a primeira etapa é configurar um projeto. O projeto contém todos os materiais processados para seu aplicativo, incluindo não apenas arquivos de código fonte, mas também arquivos de recursos como ícones, referências a arquivos externos que seu programa depende, e dados de configuração como configurações do compilador. Quando você cria um projeto, Visual C# chama o compilador C# e outras ferramentas internas para criar um conjunto executável usando os arquivos em seu projeto. Criando um novo projeto Você cria um novo projeto, clicando no menu File, apontando para New, e clicando em Project. Observação Se você selecionar Web Site em vez de Project, a IDE (ambiente de desenvolvimento integrado) Visual Web Developer abre. Este é um ambiente separado e distinto dentro do Visual Studio para criar aplicativos ASP.NET. A IDE Visual Web Developer usa o editor de código do Visual C# para edição de arquivos code-behind no C#. Se você estiver criando aplicativos da Web, você deve usar a documentação do Visual Web Developer principalmente, mas consulte Editando código (Visual C#) para obter informações sobre o editor C#. A ilustração a seguir mostra a caixa de diálogo New Project. Você pode ver que Visual C# está selecionado por padrão na janela em à esquerda, e à direita, você tem a opção de seis ou mais modelos de projeto para escolher. Se você expandir o Smart Device ou o nó Other Project Types à esquerda, você pode ver que diferentes tipos de projeto aparecem no lado direito.

Visual C# Consolidado

31

Starter Kits são outros tipos de modelo de projeto. Se você instalar um Starter Kit, você o verá listado na caixa de diálogo New Project. Para mais informações, consulte Starter Kits. Depois que você selecionar um modelo de projeto e clicar OK, Visual Studio cria o projeto e você está pronto para começar a codificação. Arquivos de projeto, referências, configurações, e recursos estão visíveis na janela Solution Explorer (Gerenciador de Soluções) à direita.

Visual C# Consolidado

32

O que há em seu projeto?

Propriedades O nó Properties representa definições de configuração que se aplicam a seu projeto inteiro e são armazenados no arquivo .csproj na sua pasta solução. Essas configurações incluem opções de compilação, segurança, configurações de implantação e muito mais. Você faz modificações em seu projeto usando o Designer de Projeto, que é um conjunto de Páginas de Propriedades que você acessa clicando com o botão direito do mouse em Properties, e selecionando Open. Para mais informações, consulte Modificando propriedades de projeto (Visual C#).

Referências No contexto de um projeto, uma referência simplesmente identifica um arquivo binário que seu aplicativo requer para executar. Normalmente, uma referência identifica um arquivo DLL como um dos arquivos de biblioteca de classe do .NET Framework. Ele também pode fazer referência um assembly .NET (chamado de um shim) que permite seu aplicativo chamar métodos em um objeto COM ou DLL Win32 nativa. Se seu programa cria uma instância de uma classe que está definida em algum outro assembly, você deve adicionar uma referência a esse arquivo em seu projeto antes de você compilar o projeto. Para adicionar uma referência, clique em Add Reference no menu Project. Todos os projetos C# por padrão incluem uma referência à mscorlib.dll, que contém as classes principais do .NET Framework. Você pode adicionar referências a DLLs adicionais do .NET Framework e outros arquivos, clicando no menu Project, e selecionando Add Reference. Observação Não confunda o conceito de uma referência de projeto com o conceito de tipos referência em C# ou outras linguagens de programação. O primeiro refere-se a um arquivo e seu local esperado no disco. O último refere-se a tipos C#, que são declarados usando a palavra-chave class.

Recursos Um recurso é um dado que está incluído no seu aplicativo mas pode ser armazenado de tal forma que pode ser modificado independentemente de outro código fonte. Por exemplo, você pode armazenar todas as suas seqüências como recursos em vez de embutí-las no código fonte. Você pode converter as seqüências em diferentes idiomas mais adiante, e adicioná-las à pasta do aplicativo que você entrega a clientes sem precisar recompilar seu assembly. Os cinco tipos de recursos definidos pelo Visual C# são: seqüências, imagens, ícones, áudio, e arquivos. Você adiciona, remove ou edita recursos usando o Designer de Recursos, que é acessado na guia Resources no Designer de Projeto.

Formulários Quando você cria um projeto Windows Forms, o Visual C# adiciona um formulário no projeto por padrão e chama-o Form1. Os dois arquivos que representam o formulário são chamados Form1.cs e Form1.designer.cs. Você escreve seu código no Form1.cs; o arquivo designer.cs é onde o Windows Forms Designer escreve o código que implementa todas as ações que você realizou arrastando e soltando controles da Caixa de Ferramentas. Você pode adicionar um novo formulário, clicando no item de menu Project, e selecionando Add Windows Form. Cada formulário tem dois arquivos associados a ele. Form1.cs, ou qualquer outro nome que você dê, contém o código fonte que você escreveu para configurar o formulário e seus controles, como caixas de listagem e caixas de texto, e responde a eventos como clique de botão e pressionamento de tecla. Em projetos simples do Windows Forms, você faz a maioria ou toda a sua codificação nesse arquivo. O arquivo Designer.cs contém o código fonte que o Forms Designer escreve quando você arrasta controles para o formulário, define propriedades na janela Properties, e assim por diante. Normalmente, você não deve editar esse arquivo manualmente.

Visual C# Consolidado

33

Observação Obviamente, se você criar um projeto de aplicativos de console, ele não conterá arquivos código fonte para Windows Forms.

Outros arquivos de código fonte Um projeto pode incluir qualquer número de arquivos .cs adicionais que pode ou não estar associado a um Windows Form específico. Na ilustração anterior do Gerenciador de Soluções, program.cs contém o ponto de entrada para o aplicativo. Um único arquivo .cs pode conter qualquer número de definições de classe e estrutura. Você pode adicionar arquivos novos ou existentes ou classes no seu projeto, clicando em Add New Item ou Add Existing Item no menu Project.

Projetando uma interface de usuário (Visual C#) No Visual C#, a maneira mais rápida e conveniente de criar sua interface de usuário (UI) é fazê-la visualmente, usando o Windows Forms Designer e o Toolbox. Há três etapas básicas para criar todas as interfaces de usuário: •

Adicionar controles a superfície de criação.

•

Definir propriedades iniciais para os controles.

•

Escrever manipuladores para eventos especificos.

Embora você também possa criar sua UI escrevendo seu próprio código, designers permitem que você realize este trabalho muito mais rapidamente que na codificação manual. Observação Você pode usar Visual C# para criar aplicativos de console que possuem uma interface simplesmente baseada em texto. Para mais informações, consulte Criando aplicativos de console (Visual C#). Adicionando controles No designer, você usa o mouse para arrastar, por Exemplo botões e caixas de texto, para uma superfície de projeto que representa o formulário. A ilustração a seguir mostra uma caixa de combinação que foi arrastado da janela Toolbox para um formulário no Windows Forms Designer.

Visual C# Consolidado

34

Enquanto você trabalha visualmente, o designer converte suas ações em código fonte C# e os grava em um arquivo de projeto chamado designer.cs onde é o nome que você deu para o formulário. Quando seu aplicativo é executado, esse código fonte irá posicionar e dimensionar os elementos de UI para que elas apareçam da mesma maneira que na superfície de projeto. Para mais informações, consulte O Windows Forms Designer. Definindo propriedades Após você adicionar um controle ao seu formulário, você pode usar a janela Properties para definir suas propriedades, como cor do plano de fundo e texto padrão. Os valores que você especificar na janela Properties são simplesmente os valores iniciais que serão atribuídos a essa propriedade quando o controle é criado em tempo de execução. Em muitos casos, esses valores podem ser acessados ou alterados programaticamente em tempo de execução simplesmente obtendo ou definindo a propriedade na instância da classe de controle em seu aplicativo. A janela Properties é útil em tempo de criação porque ela permite que você procure por todas as propriedades, eventos e métodos suportados por um controle. Para mais informações, consulte Janela Properties. Tratamento de eventos Programas com interfaces de usuário gráficas são principalmente direcionadas a eventos. Elas aguardam até que um usuário faça algo como inserir texto em uma caixa de texto, clicar em um botão, ou alterar uma seleção em uma caixa de listagem. Quando isso acontece, o controle, que é apenas uma instância de uma classe do .NET Framework, envia um evento para seu aplicativo. Você pode optar por manipular um evento escrevendo um método especial em seu aplicativo que será chamado quando o evento é recebido. Você pode usar a janela Properties para especificar que eventos deseja tratar em seu código; selecione um controle no designer e clique no botão Events, com o ícone de um raio, na barra de ferramentas da janela Properties para ver os seus eventos. O diagrama a seguir mostra o botão de eventos. Quando você adiciona um manipulador de eventos através da janela Properties, o designer automaticamente escreverá para você o corpo do método como vazio, e fica por sua conta

Visual C# Consolidado

35

escrever o código para que o método faça algo útil. A maioria dos controles geram um número grande de eventos, mas na maioria dos casos, um aplicativo somente precisará manipular alguns deles, ou mesmo somente um. Por exemplo, você provavelmente precisa manipular um evento de Click de botão, mas não é necessário manipular seu evento Paint a menos que você deseje personalizar a aparência de alguma maneira avançada. Próximas Etapas Para obter mais informações sobre interfaces de usuário do Windows Forms, consulte os seguintes tópicos: •

Criando aplicativos baseados no Windows

•

Passo a passo: Criando um formulário do Windows simples

•

Elementos de interface de usuário do Windows Forms Designer

Na biblioteca de classe do. NET Framework, System.Windows.Forms e namespaces relacionados contém as classes usadas no desenvolvimento do Windows Forms.

Editando Código Este é um conteúdo traduzido automaticamente que os membros da comunidade podem editar. Como tal, a Microsoft não pode garantir a exatidão ou fidelidade em relaçao ao conteúdo original. Você pode melhorá-lo usando os controles à direita. guest : fazer logon minhas configurações faq | sugerir alterações Ambiente de desenvolvimento do Visual C# Editando código (Visual C#) O Editor de códigos do Visual C# é um processador de texto para escrever código fonte. Assim como o Microsoft Word fornece suporte abrangente para frases, parágrafos, e gramática, o editor de códigos C# faz o mesmo para sintaxe C# e para o .NET Framework. Este suporte pode ser agrupado em cinco categorias principais: •

O IntelliSense: Documentação continuamente atualizada sobre as classes .NET Framework e os métodos básicos à medida que você digita no editor, e a geração de código automática.

•

Refactoring: reestruturação inteligente de sua base de código à medida que ela evolui durante o período de um projeto de desenvolvimento.

•

Trechos de código: Você pode procurar uma biblioteca que contém padrões de código repetidos freqüentemente.

•

Sublinhado ondulado: Notificações visuais de palavras incorretas, erro de sintaxe e situações de aviso conforme você digita.

•

Auxílios de legibilidade: Estrutura de tópicos e colorização.

O IntelliSense IntelliSense é o nome de um conjunto de recursos relacionados que são criados para minimizar o tempo gasto procurando por ajuda e para ajudar você a inserir código de forma mais precisa e eficiente. Todos esses recursos fornecem informações sobre palavras-chave de linguagem, tipos .NET Framework e assinaturas de método à medida que você digita no editor. As informações são exibidas em dicas de ferramentas, caixas de listagem, e marcas inteligentes. Visual C# Consolidado

36

Observação Muitos dos recursos do IntelliSense são compartilhados com outras linguagens do Visual Studio e estão documentadas com ilustrações no nó Ajuda de Codificação da biblioteca do MSDN. As seções a seguir fornecem uma visão geral sobre o IntelliSense, com links para a documentação mais completa.

Listas de conclusão Quando você insere código-fonte no editor, o IntelliSense exibe uma caixa de listagem que contém todas as palavras-chave C# e classes .NET Framework. Se ele encontrar uma correspondência na caixa de listagem para o nome que você está digitando, ele seleciona o item. Se o item selecionado for o que você deseja, simplesmente você pode teclar TAB e o IntelliSense terminará a digitação do nome ou palavra-chave para você. Para mais informações, consulte Listas de conclusão no C#.

Informações rápidas Quando você passa o cursor sobre um tipo .NET Framework, o IntelliSense exibirá um Quick Info ToolTip que contém a documentação sobre esse tipo básico. Para mais informações, consulte Informações rápidas.

Membros da lista Quando você inserir um tipo .NET Framework no Editor de Códigos, e então digitar o operador ponto ( . ), o IntelliSense exibe uma caixa de listagem que contém os membros do mesmo tipo. Quando você fizer uma seleção e pressionar TAB, o IntelliSense insere o nome membro. Para mais informações, consulte Membros da lista.

Informações de parâmetro Quando você inserir um nome do método no Editor de códigos, e digitar um parênteses de abertura, o IntelliSense exibirá um parâmetro Info ToolTip que mostra a ordem e tipos de parâmetros do método. Se o método estiver sobrecarregado, você pode rolar para baixo através de todas as assinaturas sobrecarregadas. Para mais informações, consulte Informações de parâmetro. Visual C# Consolidado

37

Adicionando diretivas 'using' Às vezes, você pode tentar criar uma instância de uma classe .NET Framework sem um nome suficientemente qualificado. Quando isso acontece, o IntelliSense exibe uma marca inteligente após o identificador não resolvido. Quando você clicar a marca inteligente, o IntelliSense exibirá uma lista de diretivas using que permitirá que o identificador seja resolvido. Quando você seleciona um da lista, o IntelliSense adiciona a diretiva para a parte superior de seu arquivo de código fonte e você pode continuar a codificação em sua localidade atual. Para mais informações, consulte Adicionar diretivas 'using'.

Refatoração Como uma base de código cresce e evolui durante o período de um projeto de desenvolvimento, às vezes é desejável fazer alterações para torná-lo mais legível para humanos ou mais portável. Por exemplo, convém dividir alguns métodos de backup em métodos menores ou alterar parâmetros do método, ou renomear identificadores. O recurso Refactoring, que é acessível clicando no Editor de códigos, faz tudo isso de uma maneira que é muito mais conveniente, inteligente, e completa que as ferramentas tradicionais como pesquisa e substituição. Para mais informações, consulte Refatoração.

Trechos de código Trechos de código são unidades de uso comum em código fonte C# que você pode inserir rapidamente com precisão e com o pressionamentos de apenas algumas teclas. O menu trecho de código é acessado clicando no Editor de Códigos. Você pode navegar entre os muitos trechos fornecidos com o Visual C#, e você também pode criar seus próprios trechos. Para mais informações, consulte Trechos de código (C#).

Sublinhado ondulado Sublinhado ondulado fornece comentários instantâneos sobre erros em seu código enquanto você digita. Um sublinhado ondulado vermelho identifica um erro de sintaxe como ponto-e-vírgula ausente ou chaves não correspondentes. Um sublinhado ondulado verde identifica um aviso de compilação em potencial, e azul identifica um problema Editar e Continuar. A ilustração a seguir mostra um sublinhado ondulado vermelho:

Visual C# Consolidado

38

Ajuda de Legibilidade Estrutura de tópicos Automaticamente o Editor de Códigos trata namespaces, classes e métodos como regiões que você pode recolher para facilitar a localização e leitura de outras partes do arquivo de código fonte. Você também pode criar suas próprias regiões recolhíveis, envolvendo o código com as diretivas #region e #endregion

Colorização O editor oferece diferentes cores a várias categorias de identificadores em um arquivo de código fonte C#. Para mais informações, consulte Colorização de Código .

Visual C# Consolidado

39

NAVEGANDO E PROCURANDO O Visual C# fornece as seguintes ferramentas para ajudá-lo a navegar e pesquisar o código fonte, arquivos de projeto e janelas abertas. •

Exibição de classe

•

Barras de navegação

•

Navegação CTRL+TAB

•

Localização em arquivos

Exibição de classe A janela Class View fornece uma exibição do seu projeto com base nas classes em vez de usar arquivos, como no Solution Explorer. Você pode usar a Class View para navegar rapidamente para qualquer classe ou membro da classe em seu projeto. Para acessas a Class View, clique em Class View no menu View.

Navegação CTRL+TAB A qualquer momento você pode ter várias janelas ativas em um projeto no Visual C#. Para navegar rapidamente para uma janela, pressione CTRL+TAB para exibir uma janela que lista todas as ferramentas ativas e janelas do código fonte. Mova as teclas de seta mantendo pressionada a tecla CTRL para selecionar a janela a exibir.

Visual C# Consolidado

40

Barras de navegação Na parte superior de cada janela de código do editor está a barra de navegação, que consiste em duas caixas de listagem. A da esquerda lista todas as classes definidas no arquivo atual, e a da direita lista todos os membros para a classe que está selecionado na caixa da lista à esquerda. Você pode ir diretamente para um método selecionando-o na caixa de listagem da direita.

Visual C# Consolidado

41

Localizar em arquivos Pressionando CTRL+SHIFT+F você pode abrir a caixa de diálogo Find in Files para executar pesquisa e substituir operações em um projeto inteiro. Observação Para renomear métodos ou tipos, ou alterar os parâmetros do método, use o recurso Refactoring, que é mais completo e inteligente do que pesquisar e substituir. Para mais informações, consulte Refactoração.

Visual C# Consolidado

42

CRIANDO E DEPURANDO (VISUAL C#) No Visual C# você criar um aplicativo executável clicando em Build no menu Build (ou pressionando CTRL+SHIFT+B). Você pode criar e iniciar o aplicativo em uma operação pressionando F5 ou clicando em Run no menu Debug. O desenvolvimento implica a introdução dos seus arquivos de projeto no compilador C#, que converte seu código fonte no Microsoft Intermediate Language (MSIL) e depois associa o MSIL com os metadados, recursos, manifesto e outros módulos, se houver algum, para criar um assembly. Um assembly é um arquivo executável que normalmente tem uma extensão .exe ou.dll. À medida que você desenvolve seu aplicativo, você pode criar uma versão de depuração para testá-lo e ver como ele executa. Finalmente, quando tudo está correto, você criará um versão de lançamento para implantar aos clientes. Para obter mais informações sobre assemblies, consulte Visão Geral Sobre assemblies. Criar configurações Para especificar várias configurações de criação, clique com o botão direito do mouse no item de projeto no Solution Explorer e selecione o painel Build no Project Designer. Para obter mais informações, consulte Introdução ao Project Designer e Opções de Compilação C#. O Visual Studio usa a ferramenta MSBuild para criar assemblies. O MSBuild também pode ser executado a partir da linha de comando e pode ser personalizado de várias maneiras. Para mais informações, consulte MSBuild. Construir erros Se não há erros na sintaxe C#, ou identificadores que não podem ser resolvidos em um tipo conhecido ou membro, então a compilação não terá êxito e você verá uma lista de erros em que aparece, por padrão, diretamente abaixo do editor de código. Você pode dar um clique duplo com o mouse na mensagem de erro para ir para a linha do seu código onde ocorreu o erro.

Visual C# Consolidado

43

As mensagens de erro do compilador C# são geralmente muito claras e descritivas, mas se você não puder descobrir o problema, você pode ir para a página de Ajuda da mensagem, pressionando F1 com a mensagem de erro selecionada na lista de erro. A página de Ajuda contém informações adicionais úteis. Se você ainda não puder resolver o problema, então, a próxima etapa é fazer sua pergunta em um dos grupos de notícias ou fóruns do C#. Para acessar o fóruns, clique em Ask A Question no menu Community. Observação Se você encontrar uma página de ajuda de erro de compilação que não foi útil para o seu erro específico, você pode ajudar a Microsoft melhorar a documentação, enviando uma descrição do problema. Para enviar o email, clique no link na parte inferior da página de Ajuda que contém o erro.

Configurações Versão vs. Depuração Enquanto você estiver trabalhando ativamente em seu projeto, você geralmente criará seu aplicativo usando a configuração de depuração, porque essa configuração permite que você exiba o valor de variáveis e controle a execução no depurador. Você também pode criar e testar compilações na versão de configuração para garantir que não introduziu quaisquer erros que somente só se manifestam em um tipo de compilação ou outro. Na programação do .NET Framework, esses erros são muito raros, mas eles pode acontecer. Quando você estiver pronto para distribuir seu aplicativo para usuários finais, crie uma versão de compilação, que será muito menor em tamanho e geralmente não terá melhor desempenho que a correspondente configuração de depuração. Você pode definir a configuração de compilação no painel Build do Project Designer, ou na barra de ferramentas Build. Para mais informações, consulte Compilar configurações. Depuração A qualquer momento que você estiver trabalhando no editor de código, você pode definir um ponto de interrupção (breakpoint) em uma linha de código, pressionando F9. Quando você pressionar F5 para executar seu aplicativo no depurador do Visual Studio, o aplicativo irá parar naquela linha e você poderá examinar o valor de qualquer variável, ou observar como ou quando a execução se liberta de um loop, passar pelo código linha a linha pressionando F10, ou configurar pontos de parada adicionais.

Você também pode definir pontos de interrupção condicionais (tracepoints), que só irão parar a execução se uma condição especificada for satisfeita. Tracepoints são semelhantes aos pontos de

Visual C# Consolidado

44

interrupção exceto que eles não param a execução, mas simplesmente gravam o valor da variável especificada para a janela de saída. Para mais informações, consulte Pontos de interrupção e Tracepoints. Quando a execução é interrompida em um ponto de interrupção, você pode focalizar sobre qualquer variável no escopo para exibir informações sobre essa variável. A ilustração a seguir mostra uma dica de dados no depurador:

Você pode depurar seu código uma linha por vez pressionando F10 após o depurador ser interrompido em um ponto de interrupção. Você pode até corrigir determinados tipos de erros em seu código, e continuar a depuração sem precisar parar e recompilar o aplicativo O depurador do Visual Studio é uma ferramenta poderosa e é válido levar um tempo para ler a documentação para compreender diferentes conceitos como Edit e Continue, Exibir Dados no Depurador, Depuração Just-In-Time e Visualizadores.

Visual C# Consolidado

45

MODELAGEM E ANÁLISE DE CÓDIGO (VISUAL C#) Não é incomum para desenvolvedores de software trabalhar com código fonte cuja arquitetura básica é desconhecida, pois ele foi escrito por outra pessoa, ou porque ele foi escrito há tanto tempo que seus criadores originais não mais recordam como ele funciona. Outro cenário comum é a necessidade de entender o conteúdo de uma biblioteca que só está disponível no formato binário. Visual C# fornece as seguintes ferramentas para ajudar você a modelar, analisar e compreender tipos e relacionamentos de tipos em código fonte como também em módulos binários (assemblies): •

Classe Designer, para representar visualmente relacionamentos de herança e associação entre tipos.

•

Pesquisador de Objetos, para examinar os tipos, métodos e eventos exportados pelos assemblies do .NET Framework, e DLLs nativas incluindo os objetos COM.

•

Metadados como fonte, para exibir informações de tipo em módulos (assemblies) gerenciados como se fosse código fonte em seu próprio projeto.

Além das ferramentas listadas acima, Visual Studio Team System inclui a ferramenta Análise de Código para Código Gerenciado que inspeciona seu código para uma variedade de problemas potenciais. Classe Designer A classe Designer é uma ferramenta gráfica para modelagem visual da relação entre tipos em um aplicativo de software ou componente; você também pode usá-la para criar novos tipos e refazer ou excluir tipos existentes. A ilustração a seguir mostra a criação de uma classe simples:

Visual C# Consolidado

46

Para adicionar um diagrama de classe a um projeto, clique em Add New Item no menu Project , e em seguida, clique em Add Class Diagram. Para mais informações, consulte Projetando e exibindo classes e tipos. Pesquisador de Objetos O Pesquisador de Objetos permite que você veja informações de tipo em DLLs nativas e gerenciadas, incluindo objetos COM. Embora as informações que você vê no Pesquisador de Objetos sejam semelhantes as que você vê no Class View, você pode usar o Pesquisador de Objetos para examinar qualquer DLL em seu sistema, não apenas aquelas referenciadas no seu próprio projeto. Além disso, o Pesquisador de Objetos também exibe comentários da documentação XML para o tipo selecionado. A ilustração a seguir mostra como o Pesquisador de Objetos exibe informações de tipo em arquivos binários.

Para mais informações, consulte Pesquisador de Objetos Os metadados como fonte: O recurso Metadata As Source (Metadados como fonte) permite que você veja informações de tipo das classes em módulos (assemblies) gerenciados como se eles fossem código fonte em seu próprio projeto. Essa é uma maneira conveniente para exibir as assinaturas para todos os métodos públicos em uma classe quando você não tem acesso ao código fonte real. Por exemplo, se você inserir a instrução System.Console.WriteLine() no editor de código, coloque o ponto de inserção no Console e clique com o botão direito do mouse e selecione Go To Definition, você verá algo parecido com um arquivo de código fonte que contém a declaração da classe Console. Essa declaração é construída a partir dos metadados no assembly usando Reflexão, e embora não exponha a implementação de todos os métodos, mostra comentários da documentação XML que estão presentes. Você também pode usar o recurso Metadata As Source, selecionando um tipo gerenciado no Pesquisador de Objetos, e clicando em Code Definition Window no menu View.

Visual C# Consolidado

47

Para obter mais informações e uma ilustração, consulte Os metadados como fonte: Análise de código para código gerenciado A ferramenta de análise de código para código gerenciado analisa informações de assemblies gerenciados e relatórios assim como possíveis problemas de segurança, e violações de regras de programação e projeto definidas nas diretrizes de projeto do Microsoft .NET Framework. Essas informações são apresentadas como avisos. Você acessa a ferramenta no Designer de Projeto clicando com o botão direito do mouse em Properties no Solution Explorer, e selecionando Open.

Visual C# Consolidado

48

ADICIONANDO E EDITANDO RECURSOS (VISUAL C#) Aplicativos do Visual C# geralmente incluem dados que não estão no código fonte. Esses dados são conhecidos como um project resource (recurso de projeto) e ele pode incluir dados binários, arquivos de texto, arquivos de áudio ou vídeo, tabelas de seqüência de caracteres, ícones, imagens, arquivos XML ou qualquer outro tipo de dados que seu aplicativo requer. Dados de recurso de projetos são armazenados em formato XML no arquivo resx. (chamado Resources.resx por padrão) que pode ser aberta no Solution Explorer. Para obter mais informações sobre os recursos de projeto, consulte Trabalhando com Arquivos de Recursos. Adicionando Recursos a Projetos Você pode adicionar recursos a um projeto clicando em Add Existing Item no menu Project, ou clicando no botão Add Resource na página Resources no Project Designer. Você pode adicionar recursos ao seu projeto como recursos vinculados, que são arquivos externos, ou como recursos incorporados, que são incorporados diretamente ao arquivo .resx. •

Quando você adiciona um recurso vinculado, o arquivo resx. que armazena suas informações de recurso de projeto inclui apenas um caminho relativo para o arquivo de recurso no disco. Se você adicionar imagens, vídeos ou outros arquivos complexos como recursos vinculados, você pode editá-los usando um editor padrão no qual você associa a esse tipo de arquivo no Resource Designer.

•

Quando você adiciona um recurso incorporado, os dados são armazenados diretamente no arquivo de recurso (.resx) do projeto. Somente seqüências de caracteres podem ser armazenadas como recursos incorporados.

Editando Recursos O Resource Designer permite que você adicione e modifique recursos de projeto durante o desenvolvimento ao associar um aplicativo padrão para editar cada recurso. Você acessa o Resource Designer clicando com o botão direito do mouse em Properties no Solution Explorer, clicando em Open e clicando na guia Resources em Project Designer. Para mais informações, consulte Páginas de Recursos, Project Designer. A ilustração a seguir mostra as opções de menu Resource Designer:

Para editar recursos incorporados, você deve trabalhar diretamente no arquivo .resx para manipular os caracteres individuais ou bytes. Isto é porque ele é mais conveniente para armazenar tipos de arquivos complexos como recursos vinculados durante o desenvolvimento. Você pode usar o Binary Editor para editar arquivos de recursos, incluindo o arquivo .resx, no nível binário em formato hexadecimal ou ASCII. Você pode usar a Image Editor para editar ícones e cursores assim como arquivos JPEG e GIF, que são armazenados como recursos vinculados. Você também pode escolher outros aplicativos como editores para esses tipos de arquivo. Para mais informações, consulte Exibindo e Editando Recursos no Resource Editor.

Visual C# Consolidado

49

Compilando Recursos em Assemblies Quando você cria seu aplicativo, o Visual Studio chama a ferramenta resgen.exe para converter os recursos do aplicativo em uma classe interna chamada Resources. Essa classe está contida no arquivo Resources.Designer.cs que está aninhado no arquivo Resources.resx no Solution Explorer. A classe Resources encapsula todos os recursos do projeto em propriedades get, somente-leitura estáticas, como uma forma de fornecer recursos fortemente tipados em tempo de execução. Quando você constrói através do Visual C# IDE, todos os dados de recurso encapsulados, incluindo os dois recursos que foram incorporados ao arquivo .resx e os arquivos vinculados, são compilados diretamente para o aplicativo assembly (o arquivo .exe ou .dll). Em outras palavras, o Visual C# IDE sempre usa a opção /resource de compilador. Se você constrói a partir da linha de comando, você pode especificar a opção de compilador /linkresource que permitirá implantar recursos em um arquivo separado do aplicativo assembly principal. Este é um cenário avançado e só é necessário em certas situações raras. Uma situação mais comum para implantação de recursos separadamente do aplicativo assembly principal é usar assemblies satélites conforme discutido abaixo. Acessando Recursos em Tempo de Execução Para acessar um recurso em tempo de execução, simplesmente referencie-o como você faria para qualquer outro membro da classe. O Exemplo a seguir mostra como recuperar um recurso bitmap que você nomeou para Image01. System.Drawing.Bitmap bitmap1 = Resources.Image01; Internamente a propriedade get utiliza a classe ResourceManager para criar uma nova instância do objeto. Para obter mais informações, consulte Recursos em Aplicativos e Gerador de Arquivos de Recurso (Resgen.exe). Recursos em Assemblies Satélites Se você estiver criando aplicativos que serão localizados (traduzidos) em vários idiomas, você pode armazenar cada conjunto de seqüência de caracteres específicos de cada cultura como um recurso em seu próprio assembly satélite. Quando você distribuir seu aplicativo, você incluirá o aplicativo assembly principal junto com qualquer montagem satélite adequada. Você pode adicionar assemblies satélite ou modificar arquivos existentes sem recompilar o aplicativo assembly principal. Para obter mais informações, consulte Criando Assemblies Satélites e Localizando e Usando Recursos para uma Cultura Específica.

Visual C# Consolidado

50

OBTENDO AJUDA (VISUAL C#) A documentação da ajuda do Visual Studio está contida na Biblioteca MSDN, que você pode instalar localmente em seu próprio computador ou rede, e que também está disponível na Internet em http://msdn.microsoft.com/Library. A versão local da biblioteca consiste em uma coleção de compactada arquivos HTML com o formato.hxs. Você pode optar por instalar a biblioteca em sua máquina total ou parcialmente; a instalação completa do MSDN fica próxima de 2 GB em tamanho e inclui documentação para muitas tecnologias Microsoft. Você pode exibir a documentação MSDN local eonline usando o navegador do Visual Studio Help chamado Microsoft Document Explorer. Existem seis maneiras para acessar a ajuda enquanto trabalha no Visual C#: •

Pesquisar F1

•

Pesquisa

•

Índice

•

Índice Analítico

•

Como Eu

•

Ajuda Dinâmica

Ajuda Online versus Local Na página de propriedades Help Options no menu Options, você pode especificar as seguintes opções para o comportamento da pesquisa, inclusive a pesquisa F1: •

Tente a Biblioteca MSDN on-line primeiro, depois a documentação local se nenhuma coincidência for encontrada.

•

Tente a Biblioteca MSDN local primeiro, depois a documentação on-line se nenhuma coincidência for encontrada.

•

Tente somente a Biblioteca MSDN local.

Essas opções também serão exibidas na primeira vez você chamar qualquer pesquisa. A documentação MSDN on-line pode conter atualizações mais recentes que a documentação local. Portanto, se você tiver uma conexão Internet enquanto trabalha no Visual C#, é recomendável que você escolha a opção de pesquisa para testar a Biblioteca MSDN on-line primeiro. De tempos em tempos, atualizações para a documentação local podem ser disponibilizadas para download. Para obter mais informações sobre atualizações documentação, verifique o Visual Studio Developer Center. Pesquisa F1 F1 fornece recursos de pesquisa contextual. No editor de código, você pode acessar a documentação da Ajuda para palavras-chave C# e classes do Framework .NET posicionando o cursor de inserção sobre ou imediatamente após a palavra-chave ou membro da classe e pressionando F1. Quando uma caixa de diálogo ou qualquer outra janela tiver o foco, você pode pressione F1 para obter ajuda sobre essa janela. Uma pesquisa F1 retorna não mais de uma página. Se nenhuma correspondência for encontrada, será exibida uma página informativa que fornece algumas dicas de solução de problemas. Pesquisa Use a interface de pesquisa para retornar todos os documentos que correspondam a qualquer termo especificado ou conjunto de termos. A interface de pesquisa tem esta aparência:

Visual C# Consolidado

51

Você também pode usar a página Help Options no menu Options para especificar se você deseja para procurar sites Codezone além da Biblioteca MSDN. Sites Codezone são mantidos por parceiros da Microsoft e fornecem informações úteis sobre o C# e o .NET Framework. Somente conteúdo Codezone estará disponível on-line. As mesmas opções de busca online versus pesquisa local se aplicam às pesquisas F1 e comum. Na interface de pesquisa você pode restringir ou expandir sua pesquisa especificando quais tipos de documentos incluir. Existem três opções, Linguagem, Tecnologia, e Tipo de Tópico. Você geralmente obterá os melhores resultados marcando somente as opções que se aplicam a seu cenário desenvolvimento atual. Índice O índice fornece uma maneira rápida para localizar documentos na sua Biblioteca MSDN local. Não se trata de uma pesquisa do texto completo; ele procura somente as palavras-chave índice que tiverem sido atribuídas a cada documento. Uma pesquisa por índice é geralmente mais rápida e mais relevante que uma pesquisa de texto completo. Se mais de um documento contiver a palavra-chave que você especificar na a caixa de pesquisa de índice, depois uma janela de resolução de ambigüidade abre e permite que você selecione dentre as opções possíveis. A janela índice estará localizada, como padrão, no lado esquerdo do Document Explorer. Você pode acessá-la a partir do menu Help do Visual C#. Índice Analítico O índice analítico da Biblioteca MSDN mostra todos os tópicos na biblioteca numa estrutura hierárquica num modo de exibição de árvore. Ele é uma ferramenta útil para navegar através da documentação para ter uma idéia do que está contido na biblioteca, e para explorar documentos que você talvez não localize através do índice ou da pesquisa. Freqüentemente, quando você encontrar um documento pelo F1, índice ou pesquisa, é útil saber onde ele está localizado no índice analítico para que você possa ver qual outra documentação relacionada existe para um determinado tópico. Clique no botão Sync with Table of Contents na barra de ferramentas Document Explorer para ver onde a página atualmente exibida está localizada na Biblioteca MSDN. Como Fazer

Visual C# Consolidado

52

Como Fazer é uma exibição filtrada da Biblioteca MSDN que principalmente inclui documentos chamados Como ou Explicação Passo-a-passo que mostram como realizar uma tarefa específica. Você pode acessar a ajuda Como Fazer na barra de ferramentas Document Explorer ou no menu Help, ou na página inicial. Cada linguagem no Visual Studio tem sua própria página Como Fazer, e a página que você vê dependerá do tipo de projeto que está atualmente ativo. Ajuda Dinâmica A janela de ajuda dinâmica exibe links para a documentação de referência do Framework .NET e a linguagem C# baseada na posição atual do ponto de inserção no editor de código. Para mais informações, consulte COMO: Personalizar a Ajuda Dinâmica.

Visual C# Consolidado

53

IMPLANTANDO APLICATIVOS C# Implantação é o processo pelo qual você distribui um aplicativo concluído ou componente para ser instalado em outros computadores. Para aplicativos de console, ou aplicativos Smart Client com base em Windows Forms, duas opções de implantação estão disponíveis: ClickOnce e o Windows Installer. Implantação ClickOnce Implantação ClickOnce permite a você publicar aplicativos do Windows para um servidor Web ou para uma rede de compartilhamento de arquivos para instalação simplificada. Para a maioria dos cenários, ClickOnce é a opção recomendada para implantação porque permite a auto atualização de aplicativos baseados no Windows que podem ser instalados e executados com a mínima interação do usuário. Para configurar propriedades de implantação ClickOnce, você pode usar o Assistente de publicação (acessível no menu Build) ou a página Publicar no Designer de Projeto. Para mais informações, consulte Página Publicar, Designer de Projeto. Para mais informações sobre o ClickOnce, veja Implantação ClickOnce. O Windows Installer Implantação do Windows Installer permite a você criar pacotes de instalação a serem distribuídos aos usuários; o usuário executa o arquivo de instalação e segue passos com um assistente para instalar o aplicativo. Isso é feito, adicionando um projeto de instalação à sua solução; quando criado, ele cria um arquivo de instalação que você distribui para os usuários; o usuário executa o arquivo de instalação e etapas com um assistente para instalar o aplicativo. Para obter mais informações sobre o Windows Installer, consulte Implantação do Windows Installer.

Recursos do Code Editor do Visual C# Fornece ferramentas que ajudam a editar e navegar pelo seu código Visual C#.

Refatoração Refatoração é o processo de melhorar seu código depois ele foi gravado, alterando a estrutura interna do código sem alterar o comportamento do código externo. Visual C# fornece os seguintes comandos refactoring sobre o menu Refactoring: •

Extrair o método

•

Renomear

•

Encapsular o campo

•

Extrair a interface

•

Promover variável local para parâmetro

•

Remover parâmetros

•

Reordenar parâmetros

Multi-Project Refactoring O Visual Studio oferece suporte multi-Project refatoração. Todas as operações que Corrigir referências em arquivos refactoring corrigir essas referências em todos os projetos de mesmo idioma. Isso funciona para quaisquer referências projeto projeto-para-. Por exemplo, se você tiver um aplicativo de console que referencia uma biblioteca de classes, quando você renomeia um tipo

Visual C# Consolidado

54

de biblioteca (usando a Rename operação refactoring), classe as referências para o tipo de biblioteca de classe no aplicativo do console também serão atualizadas. Caixa de diálogo Alterações de visualização Muitas operações refactoring fornecem uma oportunidade para você a revisar todas as alterações de referência que uma operação refactoring deve executar no seu código, antes de confirmar a essas alterações. Uma preview reference changes opção para estas operações refactoring, será exibido na caixa de diálogo refactoring. Após selecionar essa opção e aceitar a operação refactoring, o Caixa de diálogo Alterações de visualização será exibido. Observe que a Preview Changes caixa de diálogo tem duas exibições. A exibição inferior exibirá seu código com todas as atualizações de referência devido à operação refactoring. Na caixa Preview Changes de diálogo pressionando Cancel irá parar a operação refactoring, e nenhuma alteração será feita para o seu código. Tolerant erros Refactoring Refatoração é erro falhas. Em outras palavras, você pode executar um refatoração em um projeto que não é possível criar. O processo refactoring não Entretanto, nesses casos pode atualizar referências ambíguas corretamente.

Trechos de códigos (C#) O Visual Studio fornece um novo recurso chamado trechos . de código Você pode usar trechos de código para digitar um alias curta, e então expandi-lo em uma construção de programação comuns. Por exemplo, o for trecho de código cria um loop vazia for. Alguns trechos de código são surround-com trechos de código, que permitem que você se selecionar linhas de código, escolha um trecho de código que irá incorporar as linhas de código selecionadas. Por exemplo, selecionar linhas de código depois ativar o for trecho de código cria um for loop com essas linhas de código dentro do bloco loop. Trechos de código podem tornar programa escrever código mais rápido, mais fácil, e mais confiável. Usando trechos de código Trechos de Código normalmente são usados no Editor do código pelo digitando um nome curto para o alias — um atalho — trecho de código e pressionar TAB. O menu IntelliSense também oferece um Insert Code Snippet Comando de menu, fornecendo uma lista de trechos de código disponível para ser inserida no Editor de Código. Você pode ativar a lista trecho de código, digitando Ctrl+K, depois X. Para obter mais informações, consulte COMO: Usar trechos de código (C#) e COMO: Usar trechos de código circunscritos. Após um trecho de código tenha sido escolhido, o texto do trecho de código é inserido automaticamente na posição do cursor. Nesse ponto, os campos editáveis no trecho de código são realçados em amarelo, e o primeiro campo editável é selecionado automaticamente. O campo selecionado no momento é Boxed em vermelho. No for trecho de código, por exemplo, os campos editáveis estão a variável inicializador (i por padrão (length). e a expressão comprimento) por padrão Quando um campo é selecionado, os usuários podem digitar um novo valor para o campo. Pressionar TAB percorre os campos do trecho de código editáveis; pressionando SHIFT + TAB ciclos através de em ordem inversa. Clicar em um campo coloca o cursor no campo, e duas vezes em um campo selecioná-lo. Quando um campo estiver realçado, uma dica de ferramenta pode ser exibida, oferecendo uma descrição do campo. Somente a primeira instância de um determinado campo é editável; quando esse campo estiver realçado, as outras instâncias do campo são descritas. Quando você alterar o valor de um campo editável, esse campo é alterado em todos os lugares ele é usado no trecho de código. Pressionar ENTER ou ESC será cancelar a edição de campo e retorne o editor de código para Normal.

Visual C# Consolidado

55

As cores padrão para campos trecho, códigos editáveis podem ser alteradas, modificando a Code Snippet Field configuração no painel Fonts and Colors da caixa Options de diálogo. Para obter mais informações, consulte Como alterar face da fonte, tamanho, e cores usadas no Editor:. Criar trechos de código Você pode criar e utilizar trechos de código personalizado, juntamente com os trechos de código que estão incluídos com o Visual Studio por padrão. Para obter mais informações sobre como criar trechos de código personalizado, consulte Criar trechos de código. Observação Para trechos de código C#, os caracteres que são válidos para especificar o < atalho > campo são: caracteres alfanuméricos, sinal numérico (#), o caractere til (~), o caractere de sublinhado (_), e o hífen traço caractere (-). Para obter mais informações sobre trechos de código que estão incluídos na Visual C# por padrão, consulte Trechos de código padrão.

Código Colorization Editor de Código analisa tokens e código constrói para que sejam facilmente reconhecível e distinguishable de outros conteúdos de código no Editor de Código. Após o Editor de Código analisa seu código, ele colorizes construções de código adequadamente. Símbolos Editor de Código colorizes o seguinte token tipos. Comment Código excluído Identificador Keyword Número Operador Palavra-chave pré-processamento String Seqüência (C# @ Verbatim) Tipos de usuário Usuário tipos (tipos valor) Tipos de usuário (interface) Usuário tipos (enums) Usuário tipos (representantes) Seção CDATA XML Comentário XML Atributo doc XML Comentário XML doc

Visual C# Consolidado

56

Marca doc XML Você pode modificar colorization padrão da configuração usando o Fontes e cores, Ambiente, caixa de diálogo Opções.

Palavras-chave contextuais Editor de Código colorizes palavras-chave contextuais adequadamente. O Exemplo a seguir, o tipo yield está colorized turquesa, enquanto a palavra yield está azul colorized.

Brace Colorization correspondência Editor de Código facilita colorization negrito ou colorization de realce para Brace correspondência.

Negrito Colorization Quando você editar qualquer uma dos pares construção de código a seguir a seqüência, ou pares construção de código rapidamente são exibidos em negrito para indicar uma associação entre elas: ""

Uma seqüência

@" "

Uma seqüência verbatim

#if, #endif

Pré-processamento diretivas para seções condicionais

#region, #endregion

Pré-processamento diretivas para seções condicionais

case, break

Palavras-chave instrução controle

default, break

Palavras-chave instrução controle

for, break

Palavras-chave expressão avaliação

for, continue

Palavras-chave expressão avaliação

foreach, break

Palavras-chave expressão avaliação

foreach, continue

Palavras-chave expressão avaliação

while, break

Palavras-chave expressão avaliação

while, continue

Palavras-chave expressão avaliação

Visual C# Consolidado

57

Você pode desativar este recurso por unselecting a Automatic delimiter highlighting propriedade no Geral, editor de texto, caixa de diálogo Opções.

Realçar Colorization Quando o cursor está posicionado imediatamente antes um delimitador inicial, ou imediatamente após um delimitador de término, retângulos cinza aparecem para realçar tanto inicial e final delimitadores para indicar uma associação entre eles. Esse recurso está disponível para os seguintes pares correspondentes: {}

Chaves

[]

Colchetes

()

Parêntese

Exemplo Para ilustrar Brace correspondência colorization, digite fazer (Não copie e cole) o código a seguir no Editor de Código. class A { public A() { if(true) int x =0; else int x =1; } } Configurações colorization Configurações colorization são persistentes através de Configurações do Visual Studio.

Metadados como fonte Metadados como fonte permite-lhe Exibir metadados que aparece como C# código-fonte em um buffer somente leitura. Isso permite que um modo de exibição das declarações dos tipos e membros (com nenhum implementações). Você pode exibir metadados como origem ao executar o Go To Definition Comando para tipos ou membros cujo código de fonte não está disponível do seu projeto ou solução. Observação Quando você tenta executar o Go To Definition Comando para tipos ou membros marcados como internos, o IDE (ambiente de desenvolvimento integrado) não exibe seus metadados como fonte, independentemente do se o conjunto de referência é um amigo ou não. Você pode exibir metadados como fonte no Editor de Código ou a Code Definition janela. Exibindo metadados como no Editor do código fonte Quando você executa o Go To Definition comando para um item cujo código de fonte não estiver disponível, um documento que contém uma exibição de metadados, esse item é exibido como fonte, com guias é exibida no editor do código. O nome do tipo, seguido por [from metadata], aparecerá na guia do documento. Por exemplo, se você executar o Go To Definition comando para Console metadados de Console aparece no Editor do código como código fonte C# que pareça como sua declaração, mas com nenhum implementação.

Visual C# Consolidado

58

Exibindo metadados como fonte no Code Definition Window Quando a Code Definition janela estiver ativa ou visível, o IDE executa automaticamente o Go To Definition Comando para itens sob o cursor no Editor do código e para itens que estão selecionados no Class View ou o Object Browser. Se o código fonte não está disponível para esse item, o IDE exibirá metadados do item como origem na janela Code Definition. Por exemplo, se você colocar o cursor dentro a palavra Console no Editor do código, metadados para Console aparecerá como fonte na janela Code Definition. A fonte procura algo como a Console declaração, mas com nenhum implementação. Se você deseja ver a Declaração de um item que aparece na janela Code Definition, você deve usar o Go To Definition comando porque a Code Definition janela é apenas um nível de profundidade explicitamente

Configurações do IDE Visual C# Visual configurações C# são uma configuração de janelas de ferramentas, menus e atalhos de teclado predefinida. Essas configurações são parte do recurso Configurações do Visual Studio, que você pode personalizar para ajustar seus hábitos de trabalho. Windows e modos de exibição Recurso

Exibido por padrão? Observações

Class View

Não

• •

Janela de Comando

Não

Dynamic Help Window

Não

Exibir de classe está disponível no menu View. Filtragem está ativada.

Pressionar a tecla F1 não exibe a janela da Ajuda dinâmica. Para obter mais informações sobre a janela Ajuda

Visual C# Consolidado

59

dinâmico, consulte Como: Personalizar Ajuda dinâmica ou Como controlar a janela da Ajuda dinâmico:. Pesquisador de objetos

Não

Janela Output

Não

•

Solution Explorer Sim

Não é exibida membros herdados por padrão.

Explorer de solução aparece encaixado no lado direito de IDE.

Start Page

Sim, quando você inicia o IDE

Lista de tarefas (Visual Studio)

Não

Toolbox

Sim, quando você cria um aplicativo do Windows Forms

A página inicial Exibe artigos na alimentação RSS MSDN no Visual C#.

A caixa de ferramentas aparece como uma janela que é encaixada no lado esquerdo de IDE recolhida.

Teclado Recurso

Comportamento

Teclas de atalho

Essas configurações de chave de atalho oferece suporte Visual C#: • Emulação breve • Emulação Emacs • Visual C++ 2,0 padrão teclas de atalho • Teclas de atalho padrão Studio 6.0 Visual

Atalhos de Teclado Visual C# Visual C# fornece um número de atalhos de teclado que você pode usar para executar ações sem usar o mouse ou menus.

Teclas de atalho O IDE (ambiente de desenvolvimento integrado) fornece vários esquemas de ligação do teclado predefinidos. Você pode criar seu próprio teclado personalizado esquemas de mapeamento do painel de ambiente opções na caixa de diálogo Opções teclado. Você pode acessar a caixa de diálogo Opções no menu Ferramentas. Os esquemas de ligação do teclado disponíveis incluem o seguinte: •

2003 Studio visual teclas de atalho padrão

•

6,0 Studio visual teclas de atalho padrão

•

Breve teclas de atalho padrão

•

Teclas de atalho padrão Emacs

•

Teclas de Atalho Padrão do Visual Basic 6.0

•

Visual C++ 6.0 padrão teclas de atalho

•

Visual C++ 2,0 padrão teclas de atalho

As combinações de teclas de atalho a seguir funcionam no IDE. Muitos são padrão combinações teclas usadas na maioria dos aplicativos Windows; a tabela lista a função específica que tem o pressionamento de teclas no IDE. Name (Nome)

Teclas de

Descrição

Visual C# Consolidado

60

atalho Ativar menu aplicativo

ALT + espaços

Abre o menu Programa, permitindo ao usuário para gerenciar o estado da janela do aplicativo, por exemplo, mover ou redimensionar.

Ativar menu Janela Documento

ALT + HÍFEN

Abre o menu de documento, permitindo ao usuário para gerenciar o estado da janela do documento ativo, por exemplo, mover ou redimensionar. Disponível somente enquanto no modo MDI de dentro uma janela de documento.

Ativar ferramenta menu Janela

ALT + HÍFEN

Abre o menu Janela ferramenta, permitindo ao usuário para mover a janela ferramenta no IDE. Disponível somente ao dentro de uma janela ferramenta.

Aplicativo de fechamento

ALT + F4

Fecha o IDE.

Fechar documento

CTRL+F6

Fecha o documento aplicativo ativo.

Recolher Todos os nós de árvore

Num +-

Recolhe todos os nós no modo de exibição de árvore atual.

Expandir todos os nós de árvore

Num + *

Expande todos os nós no modo de exibição de árvore atual.

Mover para Barra de menus

ALT

Ativa a barra de menus IDE principal.

Mova para ferramentas próxima

CTRL + TAB

Move para a próxima barra de ferramentas visível. Disponível somente enquanto a barra de menus principal estiver ativa.

Mover para Barra de ferramentas anterior

CTRL + SHIFT + TAB

Move para a barra de ferramentas visível anterior. Disponível somente enquanto a barra de menus principal estiver ativa.

Mova para SHIFT + ALT ferramentas Janela ferramenta

Ativa a barra de ferramentas Janela ferramenta. Disponível somente em uma janela ferramenta contendo uma barra de ferramentas.

Mover o foco de árvore abaixo

CTRL + DOWN.

Move o foco em modo de exibição de árvore para baixo sem alterar a seleção. Este atalho pode ser utilizado para selecionar vários itens na árvore.

Move o foco de árvore cima

CTRL + UP

Move o foco em modo de exibição de árvore backup sem alterar a seleção. Este atalho pode ser utilizado para selecionar vários itens na árvore.

Menu de atalho

SHIFT + F10

Exibe o menu de atalho.

Alternar visibilidade lista drop-down

F4

Oculta e mostra uma lista drop-down. Disponível somente de uma lista drop-down.

Alternar seleção foco de árvore

CTRL + SPACEBAR

Alterna uma seleção para o foco atual em modo de exibição de árvore.

Visual C# Consolidado

61

Teclas de atalho padrão configurações Development gerais Os tópicos a seguir listam as combinações de teclas padrão disponíveis para o esquema de mapeamento do teclado Visual Studio 2003. •

Lista Global teclas de atalho, definições gerais de desenvolvimento comuns combinações de teclas de atalho, bem como combinações de teclas que podem ser usadas em uma variedade de locais dentro do IDE.

•

Lista Designer de HTML teclas de atalho, definições gerais de desenvolvimento as combinações de teclas de atalho disponíveis ao trabalhar no modo Design e modo de exibição de HTML do Designer de HTML.

•

Lista XML teclas de atalho do criador, definições gerais de desenvolvimento as combinações de teclas de atalho disponíveis ao trabalhar em exibição Esquema de designer XML.

•

Lista Teclas de aceleração para o Editor de diálogo disponíveis ao trabalhar no Editor de diálogo.

as combinações de teclas de atalho

•

Lista Teclas de aceleração para o editor de imagem disponíveis ao trabalhar no editor de imagem.

as combinações de teclas de atalho

•

Lista Depuração teclas de atalho, definições gerais de desenvolvimento 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 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 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 combinações de teclas de atalho disponíveis ao trabalhar no Pesquisador de objetos.

•

Lista Macro teclas de atalho, definições gerais de desenvolvimento teclas de atalho disponíveis para trabalhar com macros.

•

Lista Ferramenta janela teclas de atalho, definições gerais de desenvolvimento combinações de teclas de atalho que exibem as janelas ferramenta vários.

•

Lista Projeto teclas de atalho, definições gerais de desenvolvimento as combinações de teclas de atalho que podem ser usadas para adicionar novos itens a um projeto, criar um projeto, ou abrir arquivos ou Projetos.

Visual C# Consolidado

as combinações

as

as as

as combinações de as

62

•

Lista Acelerador e teclas de atalho Editor de seqüência, definições gerais de desenvolvimento as combinações de teclas de atalho disponíveis ao trabalhar em componente editor, editor STRING, e Accelerator editor.

Visual C# Consolidado

63

ESCREVENDO APLICATIVOS COM O VISUAL C# C# é uma linguagem Type-Safe, orientada a objetos que é simples mas sofisticada, permitindo que os programadores para criem um abrangência dos aplicativos. Combinado com o Framework .NET, o Visual C# permite a criação de aplicativos Windows, Web Services, ferramentas de banco de dados, componentes, controles e mais. Esta seção contém informações sobre várias tecnologias da plataforma Microsoft nas quais você pode basear aplicativos C#.

Usando a Biblioteca de Classe do .NET Framework (Visual C#) A maioria dos projetos de desenvolvimento Visual C# usam amplamente a Biblioteca de Classe do .NET Framework para tudo desde acesso ao sistema de arquivos e manipulação de seqüência a controles de interface de usuário do Windows Forms e do ASP.NET. A biblioteca de classe é organizada em namespaces, cada um deles contém um conjunto de classes relacionadas e estruturas. Por exemplo, o namespace System.Drawing contém vários tipos que representam fontes, canetas, linhas, formas, cores, e assim por diante. Diretivas de uso e Referências Antes de você poder usar as classes de um dado namespace em um programa C#, você deve adicionar uma diretiva de uso para aquele namespace no seu arquivo de origem C#. Em alguns casos, você também deve adicionar uma referência para a DLL que contém o namespace; Visual C# adiciona automaticamente referências para as DLLs de biblioteca de classe mais comumente usadas. Você pode ver quais referências foram adicionadas em Solution Explorer sob o nó References. Para mais informações, consulte Criando um Projeto (Visual C#). Após ter adicionado a diretiva using para um namespace, você pode criar instâncias de seus tipos, chamar métodos, e responder a eventos no momento que eles forem declarados no seu próprio código fonte. No editor de código Visual C#, você também pode colocar o ponto de inserção sobre membro de nome ou tipo, e pressionar F1 para ver a documentação de Ajuda. Você também pode usar a ferramenta Pesquisador de Objetos e o recurso Metadata As Source para ver informações de tipo em classes e estruturas do .NET Framework. Para mais informações, consulte Modelagem e Analise de Código (Visual C#). Para mais informações •

Para obter mais informações sobre a biblioteca de classe do .NET Framework, consulte Visão geral da estrutura da biblioteca de classe .NET e Programação no .NET Framework.

•

Para obter mais informações sobre a arquitetura .NET Framework, consulte Visão Geral do .NET Framework.

•

Na Internet, o .NET Framework Developer Center possui vários artigos e exemplos de código sobre a biblioteca de classe.

•

Para obter informações sobre como executar tarefas específicas usando as bibliotecas de classe, consulte Como fazer em C# ou clique em How Do I no menu Help do Visual C#.

Visual C# Consolidado

64

Criando aplicativos do Windows Forms (Visual C#) Windows Forms é a tecnologia que você usa em Visual C# para criar aplicativos de cliente inteligente baseados no Windows que executa em .NET Framework. Quando você cria um projeto de aplicativos Windows, você está criando um aplicativo baseado no Windows Forms. Você usará o o Windows Forms Designer para criar a interface do usuário, e você terá acesso a outros recursos de design em tempo de execução, incluindo: •

Implantação ClickOnce.

•

Suporte rico a banco de dados com o controle DataGridView .

•

Barras de ferramentas e outros elementos de interface do usuário que podem ter a aparência e o comportamento do Microsoft ® Windows ® XP, do Microsoft Office, ou do Microsoft Internet Explorer.

Para obter mais informações, consulte Criando uma interface de usuário (Visual C#) e Windows Forms.

Criando Aplicativos de Console (Visual C#) C# pode ser usado para criar aplicativos de linha de comando que possuam entrada e exibam a saída no console. Esses aplicativos são ideais para aprender o desenvolvimento C# porque a interface do usuário é muito simples. Aplicativos console são também muito úteis para programas utilitários que requeiram pouca ou nenhuma interação do usuário. Para criar um aplicativo do console em no Visual C#, clique em New no menu File e selecione Project. Clique em em um modelo de projeto de aplicativo de console C#, forneça os nomes de arquivos que você deseja, e clique em OK. Use a classe System.Console Use a classe Console para ler e escrever caracteres a partir do console, individualmente ou como uma linha inteira. A saída pode ser formatada de diferentes maneiras. Para mais informações, consulte Visão Geral Sobre Formatação. Argumentos da linha comando podem ser acessados usando a matriz de seqüência de caracteres opcional associada ao método Main. Para mais informações, consulte Argumentos da Linha Comando (Guia de Programação C#). Exemplos •

Como criar um cliente de aplicativo de console:

Exemplo de parâmetros da linha de comando

Acessar e exibir dados (Visual C#) Em aplicativos Visual C#, você normalmente se conectará a bancos de dados usando a tecnologia ADO.NET conforme exposto no System.Data e namespaces relativos à biblioteca de classes do .NET Framework. Para obter mais informações sobre como trabalhar com dados, consulte Acessando dados (Visual Studio). Em aplicativos do Windows Forms, o controle principal de interface do usuário para exibir dados recuperados de bancos de dados é o DataGridView. Para mais informações, consulte DataGridView Control (Windows Forms). Conectar fontes de dados a controles de interface do usuário tais como caixas de texto e caixas de listagem é muito simples através de um recurso conhecido como vinculação de dados. Automaticamente, quando você vincula um controle a um campo em uma fonte de dados, as alterações feitas em um serão refletidas no outro. Para mais informações, consulte Vinculação de dados do Windows Forms.

Visual C# Consolidado

65

Para obter mais informações sobre a criação e gerenciamento de bancos de dados, escrever procedimentos de armazenamento e outras informações relacionadas, consulte Projetos de Servidor SQL, Livros on-line sobre Servidor SQL e Tutoriais do Servidor SQL. Os seguintes links contêm informações sobre como usar Visual Studio para acessar dados: •

Criando aplicativos de dados com Visual Studio

•

Ferramentas de Banco de DadosVisual

Na Internet, o Data Access and Storage Developer Center está sempre atualizado com novos artigos e exemplos.

Criando Aplicativos Móveis e Incorporados (Visual C#) O Microsoft Visual Studio 2005 oferece suporte rico e integrado para desenvolvimento de software compatível com dispositivos inteligentes baseados em Windows CE como Pocket PCs e Smartphones. Você pode usar o Visual C# para escrever aplicativos gerenciados que executam no .NET Compact Framework. Você irá usar a mesma interface de Editor de Códigos, designers e depurador que você usaria ao desenvolver para o PC. Simplesmente selecione de um dos modelos de projeto Smart Device disponíveis para o idioma de sua escolha, e comece a codificar. O Visual Studio também fornece emuladores para dispositivos inteligentes que permitem que você execute e depure seu código no seu computador de desenvolvimento, e ferramentas que simplificam o processo de compactação do seu aplicativo e seus recursos em arquivos CAB para implantação em dispositivos de usuário final. Para mais informações, consulte Dispositivos inteligentes. Você também pode usar o Visual Web Developer para desenvolver aplicativos Web móvel com base no ASP.NET Para mais informações, consulte Introdução aos Formulários Móveis da Web.

Visual C# Consolidado

66

CRIANDO E ACESSANDO SERVIÇOS DA WEB (VISUAL C#) XML Web Services fornecem a aplicativos a possibilidade de se comunicarem em um ambiente fracamente acoplado usando troca mensagens predefinidas construídas em torno de protocolos padrão como HTTP, XML, XSD, SOAP e WSDL. Como os protocolos e as especificações são públicos e não específicos de plataforma, XML Web Services podem ser usados para habilitar a comunicação entre aplicativos que residem no mesmo computador ou não, mesmo que eles estejam em plataformas ou dispositivos diferentes. Você não precisa entender detalhadamente cada especificação para criar ou consumir serviços da Web. As classes do .NET Framework e os assistentes do Visual Studio ajudam você a criar ou interagir com XML Web Services usando um modelo familiar de programação orientada a objetos. Para obter mais informações sobre XML Web Services, consulte Visão Geral sobre XML Web Services. Para obter informações sobre a criação e o acesso a XML Web Services usando ASP.NET, consulte XML Web Services Usando ASP.NET. Para obter informações sobre as ferramentas que o Visual Studio fornece para ajudar a criar e consumir facilmente XML Web Services, consulte XML Web Services (Visual Studio). Para obter mais informações sobre como criar e acessar XML Web Services, consulte XML Web Services em Código Gerenciado. O Web Services Developer Center na MSDN Online possui artigos e recursos adicionais.

Visual C# Consolidado

67

CRIANDO COMPONENTES (VISUAL C#) O termo componente na indústria de software é freqüentemente usado para fazer referência a um objeto reutilizável que expõe uma ou mais interfaces para clientes de uma maneira padronizada. Um componente pode ser implementado como uma classe única, ou como um conjunto de classes; o requisito primário é que a interface pública básica seja bem definida. Por exemplo, em um contexto de programação nativa do Windows, o COM (Component Object Model) requer que todos os componentes implementem a interface IUnknown além das outras interfaces especializadas. No contexto do .NET Framework, um componente é uma classe ou conjunto de classes que implementa a interface IComponent ou deriva diretamente ou indiretamente de uma classe que implementa esta interface. A implementação da classe base padrão da interface IComponent é Component. Alguns dos componentes mais comumente usados em programação no .NET Framework são os controles visuais que você adiciona ao Windows Forms como o Controle de Botão (Windows Forms), Controle de Caixa de Combinação (Windows Forms) e assim por diante. Componentes não visuais incluem o Controle de Timer, SerialPort, e ServiceController entre outros. Quando você cria um componente em C#, ele pode ser usado por clientes escritos em qualquer outra linguagem que está em conformidade com a Common Language Specification. Para criar seus próprios componentes no Visual C#, você pode usar o Component Designer para montar classes de componentes não visuais da mesma maneira que você monta no Windows Forms. Para mais informações, consulte Explicação passo a passo: Criando um aplicativo de serviço Windows no Designer de Componente. Para obter mais informações sobre programação de componente usando o Visual Studio, consulte Componentes no Visual Studio.

Desenvolvendo na Plataforma do Office (Visual C#) O Microsoft Visual Studio 2005 Tools para o Microsoft Office System permite a você personalizar documentos do Microsoft Office e o Microsoft Office Outlook usando código gerenciado. O Visual Studio Tools para o Office adiciona novas funcionalidades ao Visual Studio, tais como hospedar o Microsoft Office Word e o Microsoft Office Excel como designers no ambiente de desenvolvimento do Visual Studio, a habilidade de programar diretamente em objetos de dados e de apresentação e a habilidade de usar os controles do Windows Forms em documentos dentro do painel de tarefas Document Actions.

Programação do Office (Como Fazer em C#) Esta página fornece referência a ajuda sobre tarefas amplamente executadas de programação do Office. Para exibir outras categorias de tarefas populares abordados na Ajuda Como Fazer em C#. Gerais COMO: Atualizar Soluções de Ferramentas do Visual Studio Tools para Office Explica o procedimento que você deve executar manualmente para concluir a atualização para o Microsoft Visual Studio 2005 Tools para Office. O Excel Usando Explicações Passo-a-passo

Visual C# Consolidado

68

Demonstra três tipos básicos de tarefas: automatizar Microsoft Office Excel 2003, executar análises de dados, e trabalhar com controles. O Word Usando Explicações Passo-a-passo Demonstra maneiras de usar as ferramentas para o Microsoft Office 2003 para automatizar projetos do Microsoft Office Word 2003. COMO: Automatizar Aplicativos do Office que não Word, Excel, ou o Outlook Fornece as etapas a serem executadas em seus projetos existentes para que possa chamar código não gerenciado usando o Visual Basic ou C#. COMO: Adicionar Controles a Documentos do Office Explica como adicionar controles a documentos Office em tempo de design ou em tempo de execução. Aplicativos Word e Excel COMO: Executar Cálculos do Excel por Programação Explica como executar cálculos por programação para um intervalo ou para o aplicativo inteiro. COMO: Criar Menus do Office por Programação Fornece um Exemplo que cria um menu chamado New Menu na barra de menus no Microsoft Office Excel 2003. COMO: Criar Barras de Ferramentas do Office por Programação Fornece um Exemplo que cria uma barra de ferramentas denominada Teste no Microsoft Office Word 2003. Ele aparece próximo ao meio do documento e contém dois botões. Quando um botão é clicado, uma caixa de mensagem aparece. COMO: Manipular Erros em Projetos do Office Explica como configurar o depurador para paralisar em exceções do tempo de execução de linguagem comum.

Como: Atualizar soluções das Ferramentas do Visual Studio para o Office Após a atualização para Microsoft Visual Studio 2005 Tools for the Microsoft Office System, você pode abrir e executar seus projetos existentes no Visual Studio e eles serão atualizados para funcionam da mesma forma que eles tinham ao usar Visual Studio Tools for Office, Versão 2003. No entanto, para concluir a atualização para que você pode tirar proveito do novo sistema do projeto e ferramentas, você deve executar algumas etapas atualização manualmente. Para obter mais informações, consulte Atualizando Overview soluções do Office. Para atualizar um Ferramentas do Visual Studio para solução Office 1.

Abra uma solução existente no Visual Studio com Visual Studio 2005 Tools for Office instalado. O Visual Studio Conversion Wizard aparece.

2. 3.

Leia as informações e avisos na primeira tela, e clique em Next. Se você desejar criar um backup de sua solução, selecione Yes, create a backup before converting e especifique um local para os arquivos de backup. Se você não faça desejar criar um backup, selecione No.

4.

Clique em Next.

5.

Clique em Finish se tudo na página de resumo está correto.

Visual C# Consolidado

69

Uma caixa de diálogo aparece com informações sobre propriedades padrão para depuração do projeto. 6.

Clique Yes para atualizar para o novo projeto depuração propriedades padrão. O projeto se você clicar em No, não será compilado até que você faça alterações manualmente.

7.

Clique no link para o relatório de conversão para ver detalhes sobre o status de conversão, ou então clique em Close. A solução abre com o novo sistema do projeto visível no Solution Explorer, mais os arquivos da versão antiga da solução.

8.

Mover o código do arquivo classe principal antigo para o novo ThisDocument,

ThisWorkbook,. e Sheet Classes 9.

Excluir o arquivo classe principal antigo após remover todo o código.

10. Atualizar qualquer referência não qualificada para aplicativos com espaço para nome System.Windows.Forms.Application totalmente qualificado. Para obter mais informações, consulte " Atualizando O código " no Atualizando Overview soluções do Office. 11. Substituir todos os controles ActiveX no documento ou pasta de trabalho por controles gerenciados do Visual Studio Toolbox.

Visual C# Consolidado

70

O EXCEL USANDO EXPLICAÇÕES PASSO-A-PASSO Walkthroughs fornecem instruções passo a passo para cenários comuns e são um bom lugar para começar aprendendo sobre Microsoft Visual Studio 2005 Tools for the Microsoft Office System. Orientações as seguir demonstram vários tipos básicos de tarefas: automatizar o Microsoft Office Excel 2003, executar análise de dados, trabalhar com controles, soluções, implantação e definindo a segurança.

Coleta de dados usando um formulário do Windows Walkthrough Essa explicação passo a passo demonstra como abrir um formulário Windows de um planilha do Microsoft Office Excel 2003, coletar informações do usuário, e gravar essas informações em uma célula da planilha. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Excel Observação

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

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome WinFormInput. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o WinFormInput projeto para Solution Explorer. Adicionar um controle NamedRange para a planilha

Para adicionar um intervalo nomeado para Sheet1 1.

Selecione a célula A1 no Sheet1.

2.

Na caixa Name, digite formInput. A Name caixa está localizada à esquerda da barra de fórmulas, logo acima coluna A da planilha.

3.

Pressione ENTER. Um NamedRange controle é adicionado à célula A1. Não há nenhuma indicação visível na planilha, mas formInput aparece na caixa Name (logo acima a planilha no lado esquerdo). e na Properties janela quando a célula A1 é selecionada

Visual C# Consolidado

71

Adicionar um formulário do Windows ao projeto Criar um formulário do Windows para o usuário forneça informações prompt.

Para adicionar um formulário do Windows 1.

Selecione o projeto WinFormInput no Solution Explorer.

2.

No menu Project, clique em Add Windows Form.

3.

Nome do formulário GetInputString.vb ou GetInputString.cs. e, em seguida clique em Add O novo formulário é aberto no designer.

4.

Adicionar um TextBox e um Button. para o formulário

5.

Selecione o botão, localizar a propriedade Text na janela Properties, e alterar o texto OK.

Em seguida, adicione código para ThisWorkbook.vb ou ThisWorkbook.cs para coletar informações do usuário. Exibindo o formulário do Windows e coletando informações Criar uma instância do formulário GetInputString Windows e exibi-lo, e em seguida, escrever as informações do usuário em uma célula na planilha.

Para exibir o formulário e coletar informações 1.

Clique com o botão direito do mouse ThisWorkbook.vb ou ThisWorkbook.cs em Solution Explorer e selecione View Code.

2.

No manipulador Open de eventos de ThisWorkbook, adicione o seguinte código para declarar uma variável para o formulário GetInputString e depois exibir o formulário:

Observação Em C#, você deve adicionar um manipulador de eventos como mostrado no Startup evento abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C# private void ThisWorkbook_Startup(object sender, System.EventArgs e) { this.Open += new Microsoft.Office.Interop.Excel.WorkbookEvents_OpenEventHandler(ThisWorkbook_Open); } private void ThisWorkbook_Open() { GetInputString inputForm = new GetInputString(); inputForm.Show(); } 3.

Criar um método chamado WriteStringToCell que grave texto em um intervalo nomeado. Esse método é chamado do formulário, e entrado serão passadas para o NamedRange controle, formInput o usuário,. na célula A1 C#

public void WriteStringToCell(string formData) { Globals.Sheet1.formInput.Value2 = formData; } Próxima adicionar código ao formulário para lidar com clique o botão na evento. Enviar informações para a planilha

Para enviar informações para a planilha 1.

Clique com o botão direito do mouse GetInputString em Solution Explorer, e selecione View Designer.

Visual C# Consolidado

72

2.

Clique duas vezes no botão para abrir o arquivo de código com manipulador de eventos do botão Click adicionado.

3.

Adicione código ao manipulador de eventos para levar a entrada da caixa de texto, enviá-lo para a função WriteStringToCell, e depois feche o formulário. C#

Globals.ThisWorkbook.WriteStringToCell(this.textBox1.Text); this.Dispose(); Testando Agora você pode testar sua pasta de trabalho para certificar-se de que o formulário Windows aparecer, e se a entrada aparece nesta planilha.

Para testar sua pasta de trabalho 1.

Pressione F5 para executar o projeto.

2.

Confirme se o formulário Windows aparece.

3.

Digite Hello World na caixa de texto e clique em OK.

4.

Confirme que Hello World aparece na célula A1 da planilha. Próximas etapas

Essa explicação passo a passo mostra os fundamentos básicos do mostrando um Windows Form e dados passagem para uma planilha. Outras tarefas pode desejar executar incluem: •

Implantando o projeto. Para obter mais informações, consulte Como: Implantar arquivos de solução usando o Publish Wizard.

Alterando planilha formatação usando controles CheckBox Walkthrough: Essa explicação passo a passo mostra os fundamentos básicos do uso caixas de seleção em um planilha do Microsoft Office Excel 2003 para alterar a formatação. Você usará Microsoft Visual Studio 2005 Tools for the Microsoft Office System para criar e adicionar código ao seu projeto. Para ver o resultado como uma amostra completa, consulte Exemplo do Excel de controles. Durante este explicação passo a passo, você aprenderá como: •

Adicione texto e controles para uma planilha.

•

Formate o texto quando uma opção é selecionada.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

Microsoft Office Excel 2003. Criando o projeto

Nesta etapa, você irá criar um projeto usando Visual Studio Tools for Office pasta de trabalho do Excel.

Visual C# Consolidado

73

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Excel Formatting. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel Formatting projeto para Solution Explorer. Adicionar texto e controles a planilha

Para essa explicação passo a passo, você precisará três CheckBox controles e algum texto em um NamedRange controle.

Para adicionar três caixas de seleção 1.

Verifique se a pasta de trabalho está abra no designer visual studio e que Sheet1 está aberto.

2.

Na guia Common Controls da Toolbox, arraste um CheckBox controle para ou próxima célula B2 na Sheet1.

3. 4.

No menu View, selecione Properties Janela. Certifique-se de que que Checkbox1 esteja visível na caixa de listagem Nome de objeto da janela Properties, e altere as propriedades a seguir:

Propriedade

Value (Valor)

Name

applyBoldFont

Text

Negrito

5.

Arraste uma segunda caixa de seleção ou próxima célula B4 e alterar as seguintes propriedades:

Propriedade

Value (Valor)

Name

applyItalicFont

Text

Itálico

6.

Arraste uma caixa de seleção terceira ou próxima célula B6 e alterar as seguintes propriedades:

Propriedade

Value (Valor)

Name

applyUnderlineFont

Text

Sublinhado

7. 8.

Selecione todos os controles caixa de seleção três mantendo a tecla CTRL. Na barra de ferramentas do Excel, clique em Align Lefts e, em seguida clique em Make Vertical Spacing Equal. Os controles caixa de seleção três agora tem igual espaçamento vertical e são alinhados no lado esquerdo, na posição do primeiro controle que você selecionou. Você em seguida, será arrastar um NamedRange controle para a planilha.

Observação Você também pode adicionar o NamedRange controle digitando textFont na caixa Name.

Visual C# Consolidado

74

Para adicionar texto a um controle NamedRange 1.

Na guia Excel Controls da caixa de ferramentas, arraste um NamedRange controle à célula B9.

2.

Verificar que $B$9 aparece na caixa de texto editável, e essa célula B9 estiver selecionada. Se não estiver, clique em Célula B9 para selecioná-lo.

3.

Clique em OK.

4.

Célula B9 se torna um intervalo nomeado NamedRange1. Não há nenhuma indicação visível na planilha, mas NamedRange1 aparece no. (logo acima a planilha no lado esquerdo) quando Célula B9 estiver selecionada a Name box

5.

Certifique-se de que que NamedRange1 esteja visível na caixa de listagem Nome de objeto da janela Properties, e altere as propriedades a seguir:

Propriedade

Value (Valor)

Name

textFont

Value2

Clique em uma caixa de seleção para alterar a formatação de texto.

Em seguida, escreva o código para formatar o texto quando uma opção é selecionada. Formatação quando a opção um texto é selecionado Você nesta seção, vai escrever código para que quando o usuário seleciona uma opção de formatação, o formato do texto na planilha for alterado.

Para alterar a formatação quando uma caixa de seleção é marcada 1.

Clique com o botão direito do mouse Sheet1 e clique View Code no menu de atalho

2.

Adicione o seguinte código ao manipulador Click de eventos da caixa applyBoldFont de seleção: C#

private void applyBoldFont_Click(object sender, EventArgs e) { this.textFont.Font.Bold = this.applyBoldFont.Checked; } 3.

Adicione o seguinte código ao manipulador Click de eventos da caixa applyItalicFont de seleção: C#

private void applyItalicFont_Click(object sender, EventArgs e) { this.textFont.Font.Italic = this.applyItalicFont.Checked; } 4.

Adicione o seguinte código ao manipulador Click de eventos da caixa

applyUnderlineFont de seleção: C# private void applyUnderlineFont_Click(object sender, EventArgs e) { if (this.applyUnderlineFont.Checked == true) { this.textFont.Font.Underline = Excel.XlUnderlineStyle.xlUnderlineStyleSingle; } else { this.textFont.Font.Underline = Excel.XlUnderlineStyle.xlUnderlineStyleNone; } } 5.

Em C#, adicione manipuladores de eventos para as caixas de seleção para o Startup evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#

Visual C# Consolidado

75

Copiar Código this.applyBoldFont.Click += new EventHandler(applyBoldFont_Click); this.applyItalicFont.Click += new EventHandler(applyItalicFont_Click); this.applyUnderlineFont.Click += new EventHandler(applyUnderlineFont_Click); Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se que o texto está formatado corretamente quando você marca ou desmarca uma caixa de seleção.

Para testar sua pasta de trabalho 1.

Pressione F5 para executar o projeto.

2.

Marque ou desmarque uma caixa de seleção.

3.

Confirme que o texto está formatado corretamente. Próximas etapas

Essa explicação passo a passo mostra as noções básicas de usando caixas de seleção e formatar texto em planilhas do Excel 2003. Aqui estão algumas tarefas que podem vie em seguida: •

Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Usando um botão para preencher uma caixa de texto. Para obter mais informações, consulte Exibindo texto em uma caixa de texto em uma planilha usando um botão Walkthrough:.

Exibindo texto em uma caixa de texto em uma planilha usando um botão Walkthrough: Essa explicação passo a passo mostra os fundamentos básicos do uso botões e caixas de texto em planilhas Microsoft Office Excel 2003, e como criar projetos Excel usando Microsoft Visual Studio 2005 Tools for the Microsoft Office System. Para ver o resultado como uma amostra completa, consulte Exemplo do Excel de controles. Durante este explicação passo a passo, você aprenderá como: •

Adicionar controles a uma planilha.

•

Preencher uma caixa de texto quando um botão é clicado.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

Excel. Criando o projeto

Nesta etapa, você irá criar um projeto usando Visual Studio Tools for Office pasta de trabalho do Excel.

Para criar um novo projeto Visual C# Consolidado

76

•

Criar um projeto de pasta de trabalho do Excel com o nome My Excel Button. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel Button projeto para Solution Explorer. Adicionar controles a planilha

Para essa explicação passo a passo, será necessário um botão e uma caixa de texto na primeira planilha.

Para adicionar um botão e uma caixa de texto 1.

Verifique se a My Excel Button.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.

2.

Na guia Common Controls da caixa de ferramentas, arraste para Sheet1. um TextBox

3.

No menu View, selecione Properties Window.

4.

Certifique-que TextBox1 está visível na caixa Properties drop-down janela e alterar a Name propriedade da caixa de texto para displayText.

5.

Arraste um Button controle até Sheet1 e alterar as seguintes propriedades:

Propriedade

Value (Valor)

Name

insertText

Text

Inserir texto

Agora Escreva o código a ser executado quando o botão é clicado. Preencher a caixa de texto quando o botão é Clicked Sempre que o usuário clica no botão, Hello World! é acrescentada à caixa de texto.

Para escrever para a caixa de texto quando o botão é clicado 1. 2.

Na Solution Explorer, clique com o botão direito do mouse Sheet1 e, em seguida clique View Code no menu de atalho. Adicione o seguinte código ao manipulador Click de eventos do botão: C#

private void insertText_Click(object sender, EventArgs e) { this.displayText.Text += "Hello World! "; } 3.

Em C#, adicione um manipulador de eventos para o Startup evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#

this.insertText.Click += new EventHandler(insertText_Click); Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se que a mensagem Hello World! aparece na caixa de texto quando você clica no botão.

Para testar sua pasta de trabalho 1.

Pressione F5 para executar o projeto.

2.

Clique no botão.

Visual C# Consolidado

77

3.

Confirme que Hello World! aparece na caixa de texto. Próximas etapas

Essa explicação passo a passo mostra os fundamentos básicos do uso botões e caixas de texto em planilhas do Excel. Aqui estão algumas tarefas que podem vie em seguida: •

Implantando o projeto. Para obter mais informações, consulte Como: Implantar arquivos de solução usando o Publish Wizard.

•

Usar caixas de seleção para alterar a formatação. Para obter mais informações, consulte Alterando planilha formatação usando controles CheckBox Walkthrough:.

Programação contra eventos de um controle NamedRange Walkthrough: Essa explicação passo a passo demonstra como adicionar um NamedRange controle a um planilha do Microsoft Office Excel 2003 e programa contra seus eventos usando Microsoft Visual Studio 2005 Tools for the Microsoft Office System. Durante este explicação passo a passo, você aprenderá como: •

Adicionar um NamedRange controle para uma planilha.

•

Programa contra NamedRange Eventos de controle.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

Microsoft Office Excel 2003. Criando o projeto

Nesta etapa, você irá criar pasta de trabalho Excel usando Visual Studio Tools for Office Um do projeto.

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Named Range Events. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Named Range Events projeto para Solution Explorer. Adicionar texto e pipes intervalos para a planilha

Porque controles host são estendidos objetos do Office, você poderá adicioná-los para o documento em da mesma maneira, você adicionar o objeto nativo. Por exemplo, você pode adicionar um controle Excel NamedRange a uma planilha ao abrir o Insert menu apontando para Name, e escolher Define. Você também pode adicionar um NamedRange controle, arrastando-a partir para a planilha. o Toolbox

Visual C# Consolidado

78

Nesta etapa, você irá adicionar dois controles Intervalo Nomeado da planilha usando a e adicione texto para a planilha. o Toolbox,

Para adicionar um intervalo para a planilha 1.

Verifique se a My Named Range Events.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.

2.

Na guia Excel Controls da caixa de ferramentas, arraste um NamedRange controle à célula A1 no Sheet1. A Add NamedRange Control caixa de diálogo será exibida.

3. 4.

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

Adicionar um outro NamedRange controle a célula B3. Verificar que $B$3 aparece na caixa de texto editável, e essa célula B3 estiver selecionada. Se não estiver, clique em Célula B3 para selecioná-lo. Clique em OK. Célula B3 se torna um intervalo nomeado namedRange2.

Para adicionar texto a sua planilha 1.

Na célula A1, digite o seguinte texto:

Este é um Exemplo de um controle NamedRange. 2.

Na célula A3 (para a esquerda de namedRange2), digite o seguinte texto: Eventos:

Você nas seções a seguir, será escrever código que insere texto em namedRange2 e modifica propriedades do controle namedRange2 em resposta à BeforeDoubleClick, Change., e SelectionChange eventos de namedRange1 Adicionar código para responder ao evento BeforeDoubleClick

Para inserir texto em NamedRange2 com base no Evento BeforeDoubleClick 1.

Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs. e selecione View Code

2.

Adicione código para o namedRange1_BeforeDoubleClick manipulador de eventos é semelhante ao seguinte: C#

private void namedRange1_BeforeDoubleClick( Microsoft.Office.Interop.Excel.Range Target, ref bool Cancel) { this.namedRange2.Value2 = "The BeforeDoubleClick event occurred."; this.namedRange2.Font.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.Red); this.namedRange2.Font.Italic = true; } 3.

Em C#, você deve adicionar manipuladores de eventos para o intervalo nomeado como mostrado no Startup evento abaixo. Para obter informações sobre como criar

Visual C# Consolidado

79

manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C# this.namedRange1.BeforeDoubleClick += new Microsoft.Office.Interop.Excel. DocEvents_BeforeDoubleClickEventHandler(namedRange1_BeforeDoubleClick); this.namedRange1.Change += new Microsoft.Office.Interop.Excel. DocEvents_ChangeEventHandler(namedRange1_Change); this.namedRange1.SelectionChange +=new Microsoft.Office.Interop.Excel. DocEvents_SelectionChangeEventHandler(namedRange1_SelectionChange); Adicionar código para responder ao evento de alteração

Para inserir texto em namedRange2 com base no evento Change •

Adicione código para o NamedRange1_Change manipulador de eventos é semelhante ao seguinte: C# private void namedRange1_Change(Microsoft.Office.Interop.Excel.Range Target) { this.namedRange2.Value2 = "The Change event occurred."; this.namedRange2.Font.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.Blue); this.namedRange2.Font.Italic = false; } Observação Como duas vezes em uma célula em um intervalo do Excel entra no modo de edição, um Change evento ocorre quando a seleção é movida fora do intervalo mesmo que nenhuma alteração ao texto ocorreu. Adicionar código para responder ao evento SelectionChange

Para inserir texto em namedRange2 com base no evento SelectionChange •

Adicione código para o NamedRange1_SelectionChange manipulador de eventos é semelhante ao seguinte: C# private void namedRange1_SelectionChange(Microsoft.Office.Interop.Excel.Range Target) { this.namedRange2.Value2 = "The SelectionChange event occurred."; this.namedRange2.AddComment("SelectionChange always occurs before BeforeDoubleClick."); this.namedRange2.Font.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.Black); } Observação Porque faz duas vezes em uma célula em um intervalo do Excel com a seleção para mover para o intervalo, um SelectionChange evento ocorre antes de ocorrer o BeforeDoubleClick evento. Testar o aplicativo

Agora você pode testar sua pasta de trabalho para verificar texto que descreve os eventos de um NamedRange controle que será inserido no outro intervalo nomeado quando os eventos são aumentados.

Para testar seu documento 1. 2.

Pressione F5 para executar o projeto. Coloque o cursor no namedRange1, e verificar que o texto sobre o SelectionChange evento é inserido e que um comentário é inserido na planilha.

Visual C# Consolidado

80

3.

Duplo clique dentro namedRange1, e verifique se o texto sobre BeforeDoubleClick eventos está inserido com texto em itálico em namedRange2 vermelho.

4.

Clique fora do namedRange1 e observe que o evento de alteração ocorre quando sair Modo Edição mesmo que nenhuma alteração para o texto foi feita.

5. 6.

Alterar o texto dentro namedRange1. Clique fora do namedRange1, e verifique se o texto sobre Change evento está inserido com texto em namedRange2 azul. Próximas etapas

Essa explicação passo a passo mostra noções básicas de programação contra eventos de um NamedRange controle. Aqui estão algumas tarefas que podem vie em seguida: •

Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Programação contra eventos dos XMLNode controles modo. Para obter mais informações, consulte Alterando o painel de ações de acordo com contexto do usuário Walkthrough:.

Passo-a-passo: Concedendo e removendo permissões para uma solução do Office Essa explicação passo a passo demonstra as noções básicas de segurança no Microsoft Visual Studio 2005 Tools for the Microsoft Office System. Durante este explicação passo a passo, você aprenderá como: •

Remova a configuração de segurança padrão.

•

Adicionar um novo conjunto de permissões.

•

Testar seu projeto. Pré-requisitos

Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

Microsoft Office Excel 2003. Criando o projeto

Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Security Test. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.

O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Security Test projeto para Solution Explorer. Adicionar código para trás a planilha Nesta etapa, você adicionará uma caixa de mensagem a um evento de inicialização da planilha.

Para adicionar uma caixa de mensagem a um evento de inicialização 1.

Verifique se a My Security Test.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.

Visual C# Consolidado

81

2.

Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs,. e, em seguida clique View Code no menu de atalho

3.

Adicione o seguinte código para o Startup método dentro classe Sheet1 para mostrar uma caixa de mensagem durante a inicialização. C#

private void Sheet1_Startup(object sender, System.EventArgs e) { MessageBox.Show("Security settings are correct."); } 4.

No menu File, clique em Save All.

5.

Na caixa Save Project de diálogo, digite C:\Walkthroughs na caixa Location.

6.

Clique em Save.

7.

Pressione F5 para executar o projeto. O Excel é iniciado e aparecerá a caixa de mensagem.

8.

Fechar a caixa de mensagem.

9.

Feche o Excel.

10. No designer do Visual Studio, localize e selecione na guia para My Security Test.xls. 11. Feche My Security Test.xls (a superfície do design de planilha Excel) no designer do Visual Studio. Feche todos os instâncias do Excel antes de alterar a diretiva de segurança. Quando você criado o projeto de pasta de trabalho do Excel, o assistente adicionado um novo grupo de código de segurança e um grupo de códigos filho à diretiva de segurança Runtime no nível do usuário. Em seguida, você removerá o grupo de códigos que criou o assistente. Remover o grupo de códigos padrão Localize e remova o grupo de código padrão que foi criado.

Para remover um grupo de códigos 1.

No Painel de Controle, abra Administrative Tools.

2.

Executar Microsoft .NET Framework 2.0 Configuration.

3.

No modo de exibição de árvore no lado esquerdo, expanda .NET Framework 2.0 Configuration,, expandir Runtime Security Policy, expandir User, expandir Code Groups, Expandido All_Code e My Computer expanda VSTOProjects. Não é um GUID para cada projeto tenha criado. Expanda cada GUID para ver o caminho para o documento associado.

4.

Clique com o botão direito do mouse o GUID de C:\Walkthroughs\My Security Test\My Security Test\bin\My Security Test.xls grupo de códigos, e, em seguida clique Delete no menu de atalho. Será exibida uma caixa de diálogo perguntando se você tiver certeza que deseja excluir este grupo de códigos.

5.

Clique em Yes.

6.

Voltar para Visual Studio, e pressione F5 para executar o projeto meu teste de segurança. Será exibida informando a atual política de segurança .NET permite que não não que a personalização para executar uma mensagem de erro.

7.

Clique em OK.

Visual C# Consolidado

82

8.

Feche o Excel.

O conjunto não pode ser executado se ele não tiver permissão explícita na Diretiva de Segurança Microsoft .NET. Em seguida, conceda permissão para o conjunto usando um nome forte em vez de uma URL para prova. Dando um nome de alta segurança para o conjunto Um nome forte é geralmente mais seguro que uma URL como prova. Será criar e atribuir um nome forte o conjunto nas próximas etapas.

Para criar um nome forte 1.

No menu Project no Visual Studio, clique em My Security Test Properties.

2.

Clique na Signing guia.

3.

Selecione Sign the assembly.

4.

No, o Choose a strong name key file list clique New.

5.

Na caixa Create Strong Name Key de diálogo, digite SecurityTestKey na caixa Key file name.

6.

Desmarque a Protect my key file with a password caixa de seleção.

7.

Clique em OK. O arquivo SecurityTestKey.snk de chave aparece no Solution Explorer.

8.

No menu Build, clique em Build Solution Para criar o conjunto contra o par de chaves nome forte. Conceder confiança com base no nome de alta segurança

Agora adicionar um novo grupo de código para conceder confiança total para o conjunto com base no nome forte.

Para conceder confiança com base em nome forte 1.

Abra Microsoft .NET Framework 2.0 Configuration novamente.

2.

Clique com o botão direito do mouse no VSTOProjects nó e clique New no menu de atalho

3.

Digite o nome Security Test Strong Name para o novo grupo de códigos, e clique em Next.

4.

Na lista Choose the condition type for this code group, clique Strong Name.

5.

Clique em Import.

6.

Procure C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\My para Visual Basic ou C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\debug\My no C#, e clique em Open.

7.

Clique em Next.

8.

Clique Next para aceitar o FullTrust conjunto de permissões e clique em Finish.

9.

Fechar Microsoft .NET Framework 2.0 Configuration. Testar o aplicativo

Agora você pode testar sua pasta de trabalho para certificar-se que seu código seja executado quando a pasta de trabalho é aberta.

Para testar sua pasta de trabalho Visual C# Consolidado

83

1.

Pressione F5 para executar o projeto.

2.

Confirme se a caixa de mensagem aparece.

Passo-a-passo: Ligando uma célula de planilha a um campo de banco de dados Essa explicação passo a passo demonstra noções básicas de vinculação um único campo de dados em um banco de dados do SQL Server a um intervalo nomeado no Microsoft Office Excel 2003. Ele inclui adicionar controles que permitem que você para percorrer todos os registros da tabela. Durante este explicação passo a passo, você aprenderá como: •

Criar uma fonte de dados para um projeto do Excel.

•

Adicionar controles a uma planilha.

•

Rolar pelos registros do banco de dados.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003.

Acesso a um servidor com o Exemplo de SQL Server do Northwind. Permissões para ler e gravar no banco de dados do SQL Server.

•

Criando um novo projeto Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Simple Data Binding, usando o Visual Basic ou C#. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.

O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Simple Data Binding projeto para Solution Explorer. Criando o DataSet Use a Data Sources janela para adicionar um DataSet digitado ao seu projeto.

Para criar o DataSet 1.

Se a Data Sources janela não estiver visível, clique Show Data Sources no Data menu.

Observação Se Show Data Sources clique dentro a pasta de trabalho do Excel e depois verificar novamente.

Visual C# Consolidado

84

não estiver disponível, 2.

Clique Add New Data Source Para iniciar o Data Source Configuration Wizard.

3.

Selecione Database e, em seguida clique em Next.

Selecionar uma conexão de dados ao banco de dados de Exemplo Northwind do SQL Server ou adicionar uma nova conexão com o New Connection botão. 4.

Após uma conexão foi selecionado ou criado, clique em Next.

5.

Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next.

6.

Expanda o Tables nó na janela Database objects.

7.

Marque a caixa de seleção ao lado da Customers tabela.

8.

Clique em Finish.

O assistente adicionará a Customers tabela para a Data Sources janela. Ele também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. Adicionar controles a planilha Para essa explicação passo a passo, você precisa de dois intervalos nomeados e quatro botões na primeira planilha. Primeiro, adicione os dois intervalos nomeados a partir da Data Sources janela para que automaticamente eles são vinculados à fonte de dados. Em seguida, adicione os botões da Toolbox.

Para adicionar dois intervalos nomeados 1.

Verifique se a My Simple Data Binding.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.

2.

Abra a Data Sources janela e expanda o Customers nó.

3.

Selecione a CompanyName coluna, e clique na seta suspensa que aparece.

4.

Selecione NamedRange na lista drop-down, e arraste a CompanyName coluna à célula A1. Um NamedRange controle denominado companyNameNamedRange é criado na célula A1. Ao mesmo tempo, nomeado customersBindingSource, um adaptador de tabela, e uma DataSet instância são adicionados ao projeto. um BindingSource O controle é acoplado que por sua vez está vinculado a DataSet instância. o BindingSource,

5.

Selecione a CustomerID coluna na janela Data Sources, e clique na seta suspensa que aparece.

6. 7.

Clique NamedRange na lista drop-down, e arraste a CustomerID coluna à célula B1. É criado na célula B1, e vinculado a outro NamedRange controle chamado customerIDNamedRange o BindingSource.

Para adicionar quatro botões 1.

Na guia Common Controls Da adicionar um Button controle a célula A3 da planilha. o Toolbox, É nome Button1 este botão.

2.

Adicionar mais três botões às seguintes células nesta ordem, para que os nomes são conforme mostrado:

Célula

(Nome)

Visual C# Consolidado

85

B3

Button2

C3

Button3

D3

Button4

A próxima etapa é para adicionar texto para os botões, e em C# Adicionar manipuladores de eventos. Inicializando as controles Definir o texto do botão e adicionar manipuladores de eventos durante o Startup evento.

Para inicializar os controles 1.

Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs,. e, em seguida clique View Code no menu de atalho

2.

Adicione o seguinte código para o Sheet1_Startup método para definir o texto para cada botão. C#

this.button1.Text = "||"; 3.

Para C# só, adicionar manipuladores de eventos para o botão clique eventos para o Sheet1_Startup método. C#

this.button1.Click += new EventHandler(button1_Click); this.button2.Click += new EventHandler(button2_Click); this.button3.Click += new EventHandler(button3_Click); this.button4.Click += new EventHandler(button4_Click); Agora, adicione código para manipular os Click eventos dos botões para que o usuário pode procurar pelos registros. Adicionar código para ativar rolagem através dos registros Adicione código ao manipulador Click de eventos de cada botão para percorrer os registros.

Para mover para o primeiro registro •

Adicionar um manipulador de eventos para o Click Evento do botão Button1, e adicione o código para mover para o primeiro registro a seguir: C# private void button1_Click(object sender, System.EventArgs e) { this.customersBindingSource.MoveFirst(); }

Para mover para o registro anterior •

Adicionar um manipulador de eventos para o Click Evento do botão Button2, e adicione o código a seguir para mover a posição de volta em um: C# private void button2_Click(object sender, System.EventArgs e) { this.customersBindingSource.MovePrevious(); }

Para mover para o próximo registro •

Adicionar um manipulador de eventos para o Click Evento do botão Button3, e adicione o código a seguir para avançar a posição em um: C#

Visual C# Consolidado

86

private void button3_Click(object sender, System.EventArgs e) { this.customersBindingSource.MoveNext(); }

Para mover para o último registro •

Adicionar um manipulador de eventos para o Click Evento do botão Button4, e adicione o código a seguir para mover para o último registro: C# private void button4_Click(object sender, System.EventArgs e) { this.customersBindingSource.MoveLast(); } Testar o aplicativo

Agora você pode testar sua pasta de trabalho para certificar-se que você pode navegar através dos registros no banco de dados.

Para testar sua pasta de trabalho 1.

Pressione F5 para executar o projeto.

2.

Confirme se o primeiro registro aparece nas células A1 e B1.

3.

Clique em e B1. (Button3) botão e confirme se o registro seguinte aparece na célula A1 a>

4.

Clique nos outros botões de rolagem para confirmar que o registro muda conforme o esperado. Próximas etapas

Essa explicação passo a passo mostra os fundamentos básicos do vinculando um intervalo nomeado a um campo em um banco de dados. Aqui estão algumas tarefas que podem vie em seguida: •

Cache os dados para que ele possa ser usado off-line. Para obter mais informações, consulte Como dados de cache para uso off-line ou em um servidor:.

•

Vincular células para várias colunas em uma tabela, em vez da um campo. Para obter mais informações, consulte Walkthrough: vinculação células para várias colunas em uma tabela.

•

Usar um BindingNavigator controle para percorrer os registros. Para obter mais informações, consulte COMO: Navegar em dados com o controle BindingNavigator do Windows Forms.

Walkthrough: vinculação células para várias colunas em uma tabela Essa explicação passo a passo demonstra noções básicas de vinculação várias células em uma planilha do Microsoft Office Excel 2003 a campos no banco de dados Northwind do SQL Server. Durante este explicação passo a passo, você aprenderá como: •

Adicionar controles a uma planilha.

•

Salva qualquer alteração de dados de volta para o banco de dados.

•

Testar seu projeto. Observação

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

Visual C# Consolidado

87

Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003.

Acesso a um servidor com o Exemplo de SQL Server do Northwind. Permissões para ler e gravar no banco de dados do SQL Server.

•

Criando um novo projeto Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Complex Data Binding, usando o Visual Basic ou C#. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Complex Data Binding projeto para Solution Explorer. Criando o DataSet

Use a Data Sources janela para adicionar um DataSet digitado ao seu projeto.

Para criar o DataSet 1.

Se a Data Sources janela não estiver visível, clique Show Data Sources no Data menu.

Observação Se Show Data Sources clique dentro a pasta de trabalho do Excel e depois verificar novamente. não estiver disponível, 2. 3.

Clique Add New Data Source Para iniciar o Data Source Configuration Wizard. Selecione Database e, em seguida clique em Next.

Selecionar uma conexão de dados ao banco de dados de Exemplo Northwind do SQL Server ou adicionar uma nova conexão com o New Connection botão. 4.

Após uma conexão foi selecionado ou criado, clique em Next.

5.

Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next.

6.

Expanda o Tables nó na janela Database objects.

7.

Marque a caixa de seleção ao lado da Employees tabela.

8.

Clique em Finish.

O assistente adicionará a Employees tabela para a Data Sources janela. Ele também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. Adicionar controles a planilha Para essa explicação passo a passo, você precisa um ListObject controle e um Button controle na primeira planilha. Primeiro, adicione o ListObject controle a partir da Data Sources janela para que ela está vinculada automaticamente à fonte de dados. Em seguida, adicione o Button controle da Toolbox.

Para adicionar um ListObject Visual C# Consolidado

88

1.

Verifique se a My Complex Data Binding.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.

2.

Abra a Data Sources janela e selecione o Employees nó.

3.

Clique na seta suspensa que aparece.

4.

Selecione ListObject na lista drop-down, e arraste a Employees tabela à célula A6. Um ListObject controle denominado EmployeesListObject é criado na célula A6. Ao mesmo tempo, nomeado EmployeesBindingSource, um adaptador de tabela, e uma DataSet instância são adicionados ao projeto. um BindingSource O controle é acoplado que por sua vez está vinculado a DataSet instância. o BindingSource,

Para adicionar um botão •

Na guia Common Controls Da adicionar um Button controle a célula A4 da planilha. o Toolbox,

A próxima etapa é para adicionar texto ao botão quando a planilha abre. Inicialização do controle Adicionar texto ao botão no manipulador Startup de eventos.

Ao inicializar o controle 1.

Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs,. e, em seguida clique View Code no menu de atalho

2.

Adicione o seguinte código para o Sheet1_Startup método para definir o texto para o b utton. C#

this.button1.Text = "Save"; 3.

C# somente, para adicionar um manipulador de eventos para o Click evento para o

Sheet1_Startup método. C# this.button1.Click += new EventHandler(button1_Click); Agora, adicione código para manipular o Click Evento do botão. Salvar alterações no banco de dados As alterações tenham sido feitas o dados existe somente no dataset local até que eles são salvos explicitamente volta para o banco de dados.

Para salvar as alterações feitas o banco de dados •

Adicionar um manipulador de eventos para o Click evento do b utton, e adicione o código a seguir para confirmar todas as alterações que foram feitas no dataset volta para o banco de dados: C# private void button1_Click(object sender, EventArgs e) { try { this.employeesTableAdapter.Update(this.northwindDataSet.Employees); } catch (System.Data.DataException ex) { MessageBox.Show(ex.Message); } }

Visual C# Consolidado

89

Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se de que os dados aparecem como esperado, e que você pode manipular os dados de um objeto lista.

Para testar a vinculação de dados Pressione F5.

•

Verifique que quando abrir a pasta de trabalho, o objeto lista é preenchido com dados da tabela Employees.

Para modificar dados 1.

Clique em Célula B7, que deve conter o nome Davolio.

2.

Digite o nome Anderson, e pressione ENTER.

Para modificar um cabeçalho de coluna 1.

Clique na célula que contém no cabeçalho LastName da coluna.

2.

Digitar Last Name, incluindo um espaço entre as duas palavras, e pressione ENTER.

Para salvar dados 1.

Clique Save na planilha.

2.

Feche a pasta de trabalho. Clique em No Quando solicitado a salvar as alterações feitas.

3.

Pressione F5 para executar o projeto novamente. O objeto lista é preenchido com dados da tabela Employees.

4.

Observe que o nome na célula B7 é ainda Anderson, que é a alteração de dados que você feitas e salvas volta para o banco de dados. No cabeçalho LastName da coluna foi alterado para seu formato original sem nenhum espaço, porque no cabeçalho da coluna não está vinculado ao banco de dados e você não foi salvar as alterações feitas para a planilha.

Para adicionar novas linhas 1.

Selecione uma célula dentro do objeto lista. Uma nova linha aparece na parte inferior da lista, com um asterisco (*.) na primeira célula da nova linha

2.

Adicionar as informações a seguir na linha vazia:

CódigoDoFuncionário

Sobrenome

FirstName

Título

10

ITO

Shu

Gerenciador de vendas

Para excluir linhas 1. 2.

Selecionar linha 16, que deve conter a nova linha que você adicionou, clicando no número 16 no lado esquerdo da planilha. No menu Edit, clique em Delete.

Para classificar as linhas na lista 1.

Selecione uma célula dentro da lista. Botões de seta aparecem em cada cabeçalho de coluna.

2.

Clique no botão SETA no cabeçalho da Last Name coluna.

3.

Clique em Sort Ascending.

Visual C# Consolidado

90

As linhas são classificadas em ordem alfabética por sobrenome.

Para filtrar informações 1.

Selecione uma célula dentro da lista.

2.

Clique no botão SETA no cabeçalho da Title coluna.

3.

Clique em Sales Representative. A lista mostra somente as linhas que têm Sales Representative na coluna Title.

4.

Clique no botão SETA no cabeçalho da Title coluna novamente.

5.

Clique em (All). Filtragem é removida e todas as linhas aparecem. Próximas etapas

Essa explicação passo a passo mostra os fundamentos básicos do vinculando uma tabela em um banco de dados a um objeto de lista. Aqui estão algumas tarefas que podem vie em seguida: •

Cache os dados para que ele possa ser usado off-line. Para obter mais informações, consulte Como dados de cache para uso off-line ou em um servidor:.

•

Implantar a solução. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Criar uma relação mestre / detalhes entre um campo e uma tabela. Para obter mais informações, consulte Criando uma relação mestre / detalhes usando um DataSet em cache Walkthrough:.

Criando uma relação mestre / detalhes usando um DataSet em cache Walkthrough: Essa explicação passo a passo demonstra criar uma relação mestre / detalhes em uma planilha, e cache os dados para que a solução pode ser usada off-line. Durante este explicação passo a passo, você aprenderá como: •

Adicionar controles a uma planilha.

•

Configurar um DataSet para ser armazenados em uma planilha.

•

Adicione código para Habilitar rolagem pelos registros.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003.

Acesso ao Exemplo de SQL Server do Northwind. O banco de dados pode ser no seu computador de desenvolvimento ou em um servidor. •

Permissões para ler e gravar no banco de dados do SQL Server.

Visual C# Consolidado

91

Criando um novo projeto Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Master-Detail, usando o Visual Basic ou C#. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.

O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My MasterDetail projeto para Solution Explorer. Criando o DataSet Use a Data Sources janela para adicionar um DataSet digitado ao seu projeto.

Para criar o DataSet 1.

Se a Data Sources janela não estiver visível, clique Show Data Sources no Data menu.

2.

Clique Add New Data Source Para iniciar o Data Source Configuration Wizard.

3.

Selecione Database e, em seguida clique em Next.

Selecionar uma conexão de dados ao banco de dados de Exemplo Northwind do SQL Server ou adicionar uma nova conexão usando o New Connection botão. 4.

Após selecionar ou criar uma conexão, clique em Next.

5.

Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next.

6.

Expanda o Tables nó na janela Database objects.

7.

Selecione a Orders tabela e a Order Details tabela.

8.

Clique em Finish.

O assistente adicionará as duas tabelas para a Data Sources janela. Ele também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. Adicionar controles a planilha Nesta etapa, você adicionará um intervalo nomeado, um objeto de lista, e dois botões à primeira planilha. Primeiro, adicionar o intervalo nomeado e o objeto lista a partir da Data Sources janela para que automaticamente eles são vinculados à fonte de dados. Em seguida, adicione os botões da Toolbox.

Para adicionar um intervalo nomeado e um objeto de lista 1.

Verifique se a My Master-Detail.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.

2.

Abra a Data Sources janela e expanda o Orders nó.

3.

Selecione a OrderID coluna, e clique na seta suspensa que aparece.

4.

Clique NamedRange na lista drop-down, e arraste a OrderID coluna à célula A2. Um NamedRange controle denominado OrderIDNamedRange é criado na célula A2. Ao mesmo tempo, nomeado OrdersBindingSource, um adaptador de tabela, e uma DataSet instância são adicionados ao projeto. um BindingSource O controle é acoplado que por sua vez está vinculado a DataSet instância. o BindingSource,

5.

Role para baixo após as colunas que estão sob a Orders tabela. Na parte inferior da lista é a Order Details tabela; ele é aqui porque ele é um filho da Orders tabela. Selecionar

Visual C# Consolidado

92

esta Order Details Tabela, não a um que seja no mesmo nível como a Orders Tabela, e clique a seta suspensa que aparece. 6.

Clique ListObject na lista drop-down, e arraste a Order Details tabela à célula A6.

7.

Um ListObject controle denominado Order_DetailsListObject é criado na célula A6, e vinculado à BindingSource.

Para adicionar dois botões 1.

Na guia Common Controls Da adicionar um Button controle a célula A3 da planilha. o Toolbox, É nome Button1 este botão.

2.

Adicionar um outro Button controle a célula B3 da planilha. É nome Button2 este botão.

Em seguida, marcar DataSet para ser armazenado em cache no documento. Cache o DataSet Marcar DataSet para ser armazenado em cache no documento, tornar DataSet públicos e definindo a CacheInDocument propriedade.

Armazenar em cache DataSet 1.

Selecione NorthwindDataSet No bandeja de componentes.

2.

Na janela Properties, alterar a Modifiers propriedade para Public. DataSets deverá ser pública antes cache está ativado.

3.

Alterar a CacheInDocument propriedade para True.

A próxima etapa é para adicionar texto a botões, e no C# adicione código para ligar os manipuladores de eventos. Inicializando as controles Definir o texto do botão e adicionar manipuladores de eventos durante o Startup evento.

Ao inicializar os dados e os controles 1.

Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs,. e, em seguida clique View Code no menu de atalho

2.

Adicione o seguinte código para o Sheet1_Startup método para definir o texto para os botões. C#

this.button1.Text = ""; 3.

Para C# só, adicionar manipuladores de eventos para o botão clique eventos para o Sheet1_Startup método. C#

this.button1.Click += new EventHandler(button1_Click); this.button2.Click += new EventHandler(button2_Click); Adicionar código para ativar rolagem através dos registros Adicione código ao manipulador Click de eventos de cada botão para percorrer os registros.

Para percorrer os registros 1.

Adicionar um manipulador de eventos para o Click evento de Button1, e adicione o código a seguir para percorrer os registros para trás:

Visual C# Consolidado

93

C# private void button1_Click(object sender, EventArgs e) { this.ordersBindingSource.MovePrevious(); } 2.

Adicionar um manipulador de eventos para o Click evento de Button2, e adicione o código a seguir para avançar pelos registros: C#

private void button2_Click(object sender, EventArgs e) { this.ordersBindingSource.MoveNext(); } Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se de que os dados aparecem como esperado, e que você pode usar a solução off-line.

Para testar o cache de dados 1. 2.

Pressione F5. Verifique que o intervalo nomeado e o objeto lista são preenchidos com dados da fonte de dados.

3.

Rolar pelos alguns dos registros clicando nos botões.

4.

Pasta de trabalho, salve e feche a pasta de trabalho e Visual Studio.

5.

Desativar a conexão ao banco de dados. Desconecte o cabo de rede do seu computador se o banco de dados estiver localizado em um servidor, ou parar o serviço SQL Server se o banco de dados for no seu computador de desenvolvimento.

6.

Abra o Excel, e abra My Master-Detail.xls a partir do diretório \bin (\My Detail\bin mestre-no Visual Basic) ou \My Detail\bin\debug mestre-em C#.

7.

Rolar pelos alguns dos registros para ver que a planilha opera normalmente quando desconectado.

8.

Reconectar-se ao banco de dados. Conectar-se seu computador à rede novamente se o banco de dados estiver localizado em um servidor, ou inicia o serviço SQL Server se o banco de dados for no seu computador de desenvolvimento. Próximas etapas

Essa explicação passo a passo mostra as noções básicas de criar uma relação mestre / detalhes de dados em uma planilha e cache um DataSet. Aqui estão algumas tarefas que podem vie em seguida: •

Implantar a solução. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Recuperar dados de cache para outro projeto. Para obter mais informações, consulte Como recuperar dados de uma pasta de trabalho em um servidor em cache:.

Walkthrough: atualizando um gráfico em uma planilha usando botões de opção Essa explicação passo a passo mostra os fundamentos básicos do alterando estilos do gráfico usando botões de opção em um planilha do Microsoft Office Excel 2003. Para ver o resultado como uma amostra completa, consulte Exemplo do Excel de controles. Durante este explicação passo a passo, você aprenderá como: •

Adicionar um controle de usuário para uma planilha.

Visual C# Consolidado

94

•

Alterar o estilo do gráfico quando uma opção está selecionada.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003. Adicionar um gráfico a uma planilha

Você pode criar um projeto de pasta de trabalho do Excel usando uma pasta de trabalho existente. Nessa explicação passo a passo, irá adicionar um gráfico à pasta de trabalho e Usar pasta de trabalho no Excel uma nova solução. A fonte de dados nessa explicação passo a passo é uma planilha chamada Data for Chart.

Para adicionar os dados 1.

Abra o Excel 2003. Abre uma nova pasta de trabalho.

2. 3. 4.

Clique com o botão direito do mouse na Sheet3 guia e, em seguida clique Rename no menu de atalho. Renomear a planilha para Data for Chart. Adicionar dados Data for Chart Os seguir com célula A4 sendo a parte superior esquerda E8 Canto, e o canto inferior direito: Q1

Q2

Q3

Q4

Oeste

500

550

550

600

Leste

600

625

675

700

Norte

450

470

490

510

Sul

800

750

775

790

Em seguida, adicione o gráfico para a primeira planilha.

Para adicionar um gráfico 1.

No menu Insert, clique em Chart. O Chart Wizard abre.

2.

Clique em Next, deixando os padrões selecionados.

3.

Clique na caixa Data Range e desmarque qualquer seleção padrão.

4.

Na planilha Data for Chart, selecionar o bloco de células que contém os números, que inclui A4 no canto esquerdo superior para E8 no canto direito inferior.

5.

Para aceitar todos os padrões para Step 3, clique Next em Next novamente.

6.

No Step 4, garantir que As object in: está selecionado.

Visual C# Consolidado

95

7.

Na lista As object in:, selecione Sheet1.

8.

Clique em Finish.

9.

Reposicionar o gráfico para que o canto direito superior alinhe com Célula E2.

10. Salve o arquivo para a unidade C: e nomeá-la ExcelChart.xls. 11. Feche o Excel. Criando um novo projeto Nesta etapa, você irá criar um projeto usando Visual Studio Tools for Office pasta de trabalho do Excel.

Para criar um novo projeto 1.

Criar um projeto de pasta de trabalho do Excel com o nome My Excel Chart. Verifique que Copy an existing document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.

2.

Clique no Browse botão e vá para a pasta de trabalho que você criou anteriormente nessa explicação passo a passo.

3.

Clique em OK. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel Chart projeto para Solution Explorer. Definindo Propriedades do gráfico

Quando você criar um novo projeto pasta de trabalho do Excel usando uma pasta de trabalho existente, controles host automaticamente são criados para intervalos nomeados, objetos lista, e gráficos que existem dentro da pasta de trabalho. Você pode alterar o nome do controle Chart usando a Properties janela

Para alterar o nome do controle gráfico •

Selecione o Chart controle no designer e alterar as seguintes propriedades na janela Properties:

Propriedade

Value (Valor)

Name

dataChart

HasLegend

False

Adicionar um controle de usuário ao projeto

Para adicionar um controle de usuário 1.

Selecione o My Excel Chart projeto no Solution Explorer.

2.

No menu Project, clique em Add New Item.

3.

Na caixa Add New Item de diálogo, clique User Control, nome do controle ChartOptions, e clique em Add

Para adicionar controles Windows Form ao controle de usuário 1.

Se o controle de usuário estiver não visível no designer, clique duas vezes em ChartOptions no Solution Explorer.

2.

Na guia Common Controls Da arraste um Radio Button controle para o controle de usuário, e alterar as seguintes propriedades: o Toolbox,

Propriedade

Value (Valor)

Visual C# Consolidado

96

Name

columnChart

Text

Gráfico de coluna

3.

Adicionar um botão de opção segundo para o controle de usuário, e alterar as propriedades a seguir:

Propriedade

Value (Valor)

Name

barChart

Text

Gráfico de barras

4.

Adicionar um botão de opção terceiro para o controle de usuário, e alterar as propriedades a seguir:

Propriedade

Value (Valor)

Name

lineChart

Text

Gráfico de linha

5.

Adicionar um botão de opção quarto para o controle de usuário, e alterar as propriedades a seguir:

Propriedade

Value (Valor)

Name

areaBlockChart

Text

Gráfico bloquear de área

Em seguida, escreva o código para atualizar o gráfico quando um botão de opção é clicado. Alterar o gráfico estilo quando um botão de opção é selecionada Nesta seção, você será criar um evento público sobre o controle de usuário, adicionar uma propriedade para definir o tipo de seleção, e criar um manipulador de eventos para o CheckedChanged evento de cada um dos botões de opção.

Para criar um evento e propriedade em um controle de usuário 1. 2.

No Solution Explorer, clique com o botão direito do mouse no controle de usuário e selecione View Code. Adicione código para criar um SelectionChanged evento e a Selection propriedade para a

ChartOptions classe: C# public event EventHandler SelectionChanged; private Microsoft.Office.Interop.Excel.XlChartType selectedType = Microsoft.Office.Interop.Excel.XlChartType.xlColumnClustered; public Microsoft.Office.Interop.Excel.XlChartType Selection { get { return this.selectedType; } set { this.selectedType = value; } }

Para manipular o evento CheckedChanged dos botões de opção

Visual C# Consolidado

97

1.

Definir o tipo de gráfico no manipulador CheckedChanged de eventos de botão areaBlockChart de opção e depois gerar o evento. C#

private void areaBlockChart_CheckedChanged(object sender, EventArgs e) { if (((RadioButton)sender).Checked) { this.selectedType = Microsoft.Office.Interop.Excel.XlChartType.xlAreaStacked; if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } } } 2.

Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão barChart de opção. C#

private void barChart_CheckedChanged(object sender, EventArgs e) { if (((RadioButton)sender).Checked) { this.selectedType = Microsoft.Office.Interop.Excel.XlChartType.xlBarClustered; if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } } } 3.

Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão columnChart de opção. C#

private void columnChart_CheckedChanged(object sender, EventArgs e) { if (((RadioButton)sender).Checked) { this.selectedType = Microsoft.Office.Interop.Excel.XlChartType.xlColumnClustered; if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } } } 4.

Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão lineChart de opção. C#

private void lineChart_CheckedChanged(object sender, EventArgs e) { if (((RadioButton)sender).Checked) { this.selectedType = Microsoft.Office.Interop.Excel.XlChartType.xlLineMarkers; if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } } } 5.

Em C#, você deve adicionar manipuladores de eventos para os botões de opção. Adicione o código para o ChartOptions Construtor, sob a chamada para InitializeComponent, conforme mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#

public ChartOptions() { InitializeComponent(); areaBlockChart.CheckedChanged += new EventHandler(areaBlockChart_CheckedChanged); barChart.CheckedChanged += new EventHandler(barChart_CheckedChanged); columnChart.CheckedChanged += new EventHandler(columnChart_CheckedChanged); lineChart.CheckedChanged += new EventHandler(lineChart_CheckedChanged); } Adicionar o controle de usuário a planilha Quando você cria a solução, o novo controle de usuário é automaticamente adicionado à Toolbox. Você pode, então, arrastar o controle da Toolbox. para seu Worksheet

Para adicionar o controle do usuário sua planilha 1.

No menu Build, clique em Build Solution. O ChartOptions controle de usuário é adicionado à Toolbox.

2.

Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs. e selecione View Designer

Visual C# Consolidado

98

3.

Do Toolbox arraste o ChartOptions controle de para a planilha. Um novo controle chamado ChartOptions1 é adicionado ao seu projeto. Alterar o tipo de gráfico

Nesta seção, criar um manipulador de eventos para alterar o tipo de gráfico acordo para a opção selecionada no controle de usuário.

Para alterar o tipo de gráfico que é exibido na planilha 1.

Adicionar o manipulador de eventos a seguir para a Sheet1 classe. C#

private void ChartOptions1_SelectionChanged(object sender, EventArgs e) { try { dataChart.ChartType = this.ChartOptions1.Selection; } catch (Exception ex) { MessageBox.Show(ex.ToString()); } } 2.

Em C#, adicione um manipulador de eventos para o controle de usuário para o Startup evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#

this.ChartOptions1.SelectionChanged += new EventHandler(ChartOptions1_SelectionChanged); Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se que o gráfico tiver estilo corretamente quando você seleciona um botão de opção.

Para testar sua pasta de trabalho 1.

Pressione F5 para executar o projeto.

2.

Selecione vários botões de opção.

3.

Confirme que o estilo do gráfico altera para correspondem à seleção. Próximas etapas

Essa explicação passo a passo mostra noções básicas sobre como usar botões de opção e estilos do gráfico nas planilhas do Excel 2003. Aqui estão algumas tarefas que podem vie em seguida: •

Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Usando um botão para preencher uma caixa de texto. Para obter mais informações, consulte Exibindo texto em uma caixa de texto em uma planilha usando um botão Walkthrough:.

•

Alterar a formatação em uma planilha usando caixas de seleção. Para obter mais informações, consulte Alterando planilha formatação usando controles CheckBox Walkthrough:.

Vinculação de Dados para controles em um painel Ações do Excel Walkthrough: Essa explicação passo a passo demonstra vinculação de dados a controles em um painel Ações no Microsoft Office Excel 2003. Os controles demonstram uma Relação mestre / detalhes entre tabelas em um banco de dados do SQL Server. Durante este explicação passo a passo, você aprenderá como:

Visual C# Consolidado

99

•

Adicionar controles a uma planilha.

•

Criar um controle painel Ações.

•

Adicionar controles Windows Forms ligados a dados a um controle painel Ações.

•

Mostrar painel de ações quando abre o aplicativo.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003.

Acesso a um servidor com o Exemplo de SQL Server do Northwind. Permissões para ler e gravar no banco de dados do SQL Server.

•

Criando o projeto A primeira etapa é para criar um projeto de pasta de trabalho do Excel.

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Excel Actions Pane. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel Actions Pane projeto para Solution Explorer. Adicionar uma nova fonte de dados ao projeto

Para adicionar uma nova fonte de dados para o projeto 1.

Se a Data Sources janela não estiver visível, clique Show Data Sources no Data menu.

Observação Se Show Data Sources clique dentro na planilha do Excel e depois verificar novamente. não estiver disponível, 2. 3.

Clique Add New Data Source Para iniciar o Data Source Configuration Wizard. Selecione Database e, em seguida clique em Next.

Selecionar uma conexão de dados ao banco de dados de Exemplo Northwind do SQL Server ou adicionar uma nova conexão com o New Connection botão. 4.

Clique em Next.

5.

Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next.

6.

Expanda o Tables nó na janela Database objects.

Visual C# Consolidado

100

7. 8. 9.

Marque a caixa de seleção ao lado da Suppliers tabela. Expandir a Products tabela e selecione ProductName, SupplierID, QuantityPerUnit. e UnitPrice Clique em Finish.

O assistente adiciona a Suppliers tabela e Products Tabela à janela Data Sources. Ele também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. Adicionar controles a planilha Em seguida, adicione um NamedRange controle e um ListObject controle à primeira planilha.

Para adicionar um NamedRange e um controle ListObject 1.

Verifique se a My Excel Actions Pane.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.

2.

Na janela Data Sources , expanda a Suppliers tabela.

3.

Clique na seta suspensa no nó Company Name, e selecione NamedRange.

4.

Arraste Company Name a partir da Data Sources janela para na Sheet1 Célula A2. Um NamedRange controle denominado CompanyNameNamedRange é criado, e o de texto aparece na célula A2. Ao mesmo tempo, nomeado suppliersBindingSource, um adaptador de tabela, e um DataSet são adicionados ao projeto. um BindingSource O controle é acoplado que por sua vez está vinculado a DataSet instância. o BindingSource,

5.

Na janela Data Sources, role para baixo após as colunas que estão sob a Suppliers tabela. Na parte inferior da lista é a Products tabela; ele é aqui porque ele é um filho da Suppliers tabela. Selecionar esta Products Tabela, não a um que seja no mesmo nível como a Suppliers Tabela, e clique a seta suspensa que aparece.

6.

Clique ListObject na lista drop-down, e arraste a Products tabela para células A6 em Sheet1. Um ListObject controle denominado ProductNameListObject é criado na célula A6. Ao mesmo tempo, e um adaptador de tabela são adicionados ao projeto. nomeado productsBindingSource, um BindingSource O controle é acoplado que por sua vez está vinculado a DataSet instância. o BindingSource,

7.

No C# somente, selecione suppliersBindingSource No bandeja de componentes, e alterar a Modifiers propriedade para Internal na janela Properties. Adicionar controles ao painel de ações

Em seguida, você precisa um controle painel Ações que contenha uma caixa de combinação.

Para adicionar um controle painel Ações 1.

Selecione o My Excel Actions Pane projeto no Solution Explorer.

2.

No menu Project, selecione Add New Item.

3.

Na caixa Add New Item de diálogo, selecione Actions Pane Control, nomeá-la ActionsControl e clique em Add

Para adicionar controles Windows Forms ligados a dados a um controle painel Ações 1.

Das Common Controls guias da Toolbox, arraste um ComboBox controle para o controle painel Ações.

Visual C# Consolidado

101

2.

Alterar a Size propriedade para 171, 21.

3.

Redimensionar o controle de usuário para ajustar os controles. Vinculando o controle no painel Ações a dados

Neste seção, você será definir a fonte de dados de à mesma fonte de dados como o NamedRange controle em uma planilha.. com a mesma fonte de dados que o NamedRange controle em uma planilha o ComboBox o ComboBox

Para definir propriedades de vinculação de dados do controle 1. 2.

Clique com o botão direito do mouse no controle painel Ações e selecione View Code a partir do menu de atalho Adicione o seguinte código ao evento Load do controle painel Ações: C#

private void ActionsControl_Load(object sender, EventArgs e) { this.comboBox1.DataSource = Globals.Sheet1.suppliersBindingSource; this.comboBox1.DisplayMember = "CompanyName"; } 3.

Em C#, você deve criar um manipulador de eventos para o ActionsControl. Você pode colocar este código no construtor ActionsControl como mostrado abaixo. Para obter mais informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#

public ActionsControl() { InitializeComponent(); this.Load += new EventHandler(ActionsControl_Load); } Mostrando o Painel de Ações Você nesta seção, vai escrever código para mostrar o painel Ações. O painel Actions ficará visível depois controles são adicionados a ele.

Para mostrar o painel Ações 1.

Clique com o botão direito do mouse ThisWorkbook.vb no Solution Explorer, ou ThisWorkbook.cs,. e, em seguida clique View Code no menu de atalho

2.

Criar uma nova instância do controle do usuário na classe ThisWorkbook, da seguinte maneira: C#

ActionsControl actions = new ActionsControl(); No manipulador Startup de eventos de ThisWorkbook, adicione código de forma que ele tenha como no Exemplo a seguir: C# private void ThisWorkbook_Startup(object sender, System.EventArgs e) { this.ActionsPane.Controls.Add(actions); } Testar o aplicativo Agora você pode testar seu documento para verificar o painel Ações que é aberto quando o documento for aberto. Você testará para a relação mestre / detalhes entre os controles no painel de ações e os controles da planilha.

Para testar seu documento 1.

Pressione F5 para executar o projeto.

2.

Confirme se o painel Actions está visível.

Visual C# Consolidado

102

3.

Selecione uma empresa na caixa Lista. Verifique se o nome da empresa está listado no controle NamedRange e se os detalhes do produto estão listados no ListObject controle.

4.

Selecione várias empresas para verificar o nome da empresa e Detalhes do Produto altere conforme apropriado. Próximas etapas

Essa explicação passo a passo mostra as noções básicas de vinculação de dados a controles em um painel Ações no Excel. Aqui estão algumas tarefas que podem vie em seguida: •

Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Ligação de dados a controles no Word. Para obter mais informações, consulte Vinculação de Dados para controles em um painel Ações do Word Walkthrough:.

•

Mostrar e ocultar controles no painel de ações. Para obter mais informações, consulte Alterando o painel de ações de acordo com contexto do usuário Walkthrough:

Implantando um Word ou Solution do Excel usando um manifesto Deployment Walkthrough: Essa explicação passo a passo demonstra como implantar uma solução o Microsoft Office Excel ou Microsoft Office Word em um compartilhamento de rede em um servidor. Será posicionado no final do explicação passo a passo, o possível para executar a solução no servidor do seu computador de desenvolvimento. Em um ambiente de produção, uma Microsoft Visual Studio 2005 Tools for the Microsoft Office System solução geralmente é publicada primeiro a um servidor de teste, e depois ele é reimplantado em um servidor de produção depois que o departamento de TI aprovar-. Você nessa explicação passo a passo, será emular esse processo, publicando uma solução em um local temporário no seu computador de desenvolvimento, e então redeploying a solução do local de publicação para um servidor. Para obter mais informações sobre as opções para implantar a solução, consulte Modelos de implantação. Durante este explicação passo a passo, você aprenderá como: •

Do Publish Wizard uso para publicar sua solução em um local no seu computador de desenvolvimento.

•

Manualmente relançamento a solução do seu computador local para um compartilhamento de rede em um servidor.

•

Modificar o manifesto do aplicativo que está incorporado no documento para apontar para o novo local manifesto de implantação programaticamente.

•

Editar a manifesto de implantação para apontar para a nova localização do manifesto do aplicativo externos.

•

Editar o manifesto do aplicativo externo para apontar para o novo local do conjunto e a manifesto de implantação. Pré-requisitos

Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

O Word Microsoft Office 2003 ou Microsoft Office Excel 2003. Observação

Visual C# Consolidado

103

Essa explicação passo a passo pressupõe que você estiver implantando uma solução Word. Se você quiser executar explicação passo a passo com uma solução Excel, o substitua o nome do projeto do Word com o nome do seu projeto do Excel em todos os códigos e exemplos XML. •

Acesso a um servidor de rede para implantação. Essa explicação passo a passo pressupõe que você são redeploying sua solução para o \\DeployServer\ShareFolder compartilhamento de rede.

•

Privilégios de administrador no computador de desenvolvimento, para que você possa definir a diretiva de segurança para um local de rede. Criando o projeto

Nesta etapa, você irá criar um projeto Documento do Word.

Para criar um novo projeto •

Criar um projeto Documento do Word com o nome WordDeployment. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.

Abre o novo documento do Word no designer e adiciona o WordDeployment projeto para Solution Explorer o Visual Studio. Adicionar código para trás o documento Nesta etapa, você adicionará uma caixa de mensagem ao manipulador Startup de eventos do documento. Isso permitirá que você para verificar se a solução está funcionando quando você abre o documento rapidamente.

Para adicionar uma caixa de mensagem a um evento de inicialização 1.

Clique com o botão direito do mouse ThisDocument.vb no Solution Explorer, ou ThisDocument.cs,. e, em seguida clique View Code no menu de atalho

2.

Adicione o seguinte código ao manipulador Startup de eventos dentro a ThisDocument classe para mostrar uma caixa de mensagem durante a inicialização. C#

private void ThisDocument_Startup(object sender, System.EventArgs e) { MessageBox.Show("The document is deployed correctly."); } 3.

Pressione F5 para executar o projeto. Inicia o Word e a caixa de mensagem aparece.

4.

Fechar a caixa de mensagem.

5.

Sair do Word.

Em seguida, você publicará nesta solução. Publicando a solução Nesta etapa, você publicará a solução em um local temporário no computador local.

Para publicar a solução 1.

Clique com o botão direito do mouse o nó de projeto no Solution Explorer.

2.

Clique Publish no menu de atalho. O Publish Wizard aparece.

3. 4.

Na caixa Specify the location to publish this application, digite C:\TestDeploy. Clique em Finish.

Visual C# Consolidado

104

O documento de Solução e manifesto de implantação são copiados para C:\TestDeploy. O conjunto de solução, atualizado manifesto do aplicativo, e cópias do documento de Solução e manifesto de implantação são copiadas para C:\TestDeploy\WordDeployment_1.0.0.0. Para obter mais informações, consulte Implantando o Word e Excel Solutions. 5.

Feche o WordDeployment projeto no Visual Studio.

Observação O conjunto não tem permissão para executar ainda, para que ele se você tentar executar a solução será lançar um erro. Você irá atualizar sua diretiva de segurança para conceder permissão de confiança total ao conjunto em uma etapa posterior. Quando você publicar uma solução, o manifesto do aplicativo incorporado no aponta de documento de solução para o caminho completo da manifesto de implantação. Se você relançamento os arquivos de solução para outro local, deverá atualizar o manifesto do aplicativo incorporado para apontar para a nova localização da manifesto de implantação. Você também deve atualizar a manifesto de implantação e o manifesto do aplicativo externo para apontar para os novos locais de arquivo. Atualizando o manifesto Application incorporados Para editar o manifesto do aplicativo incorporado, use a ServerDocument classe que Visual Studio Tools for Office fornece. Quando você usa a ServerDocument classe, você deve executar o código em um novo projeto (não a Visual Studio Tools for Office Solução), como um projeto de console, e o Visual Studio Tools for Office documento de solução deve ser fechado. Observação Inclui Visual Studio Tools for Office um Exemplo que demonstre como criar uma ferramenta que pode ser usada para editar o manifesto do aplicativo incorporado. Para obter mais informações, consulte Aplicativo Manifest Exemplo Editor.

Para atualizar o manifesto do aplicativo incorporado 1.

Criar um novo projeto Console Application.

2.

Do Microsoft.VisualStudio.Tools.Applications.Runtime Adicionar referências para e System.Windows.Forms montagens para este projeto.

3.

Abra o arquivo Program.cs ou Module1.vb, e adicione a seguinte Imports ou using instrução para o topo do arquivo. C#

using Microsoft.VisualStudio.Tools.Applications.Runtime; 4.

Copie o código a seguir para a Main função. Este código cria uma ServerDocument que fornece acesso ao manifesto do aplicativo incorporado de seu documento de solução. O código atribui o novo caminho manifesto de implantação para a DeployManifestPath propriedade, e salva e fecha o ServerDocument.. o ServerDocument C#

ServerDocument sd = null; try { sd = new ServerDocument(@"C:\TestDeploy\WordDeployment.doc"); sd.AppManifest.DeployManifestPath = @"\\DeployServer\ShareFolder\WordDeployment.application"; sd.Save(); } finally { if (sd != null) { sd.Close(); } } 5.

Pressione F5 para executar o projeto.

Visual C# Consolidado

105

Uma janela do console aparece rapidamente enquanto o manifesto do aplicativo incorporado está sendo atualizado, e fecha a janela do console. Atualizando o manifesto de implantação Agora que você atualizou o manifesto do aplicativo incorporado no documento Visual Studio Tools for Office de solução, você deve atualizar a manifesto de implantação para apontar para a nova localização do manifesto do aplicativo externos.

Para atualizar a manifesto de implantação 1.

Abra a manifesto de implantação em um editor de texto, como o Bloco de notas. A manifesto de implantação é denominado WordDeployment.application, e está localizado na pasta C:\TestDeploy de publicação.

2.

Defina o codebase atributo do elemento 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: 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#

Visual C# Consolidado

364

void DoWork() { } void DoWork() { } void DoWork() { }

Especificação da Linguagem C# Para obter mais informações, consulte as seções a seguir no Especificação da Linguagem C#: •

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 :

O argumento Tipo deve ser ou derivar de classe base especificada.

where T :

O argumento Tipo deve ser ou implementam a interface especificada. Várias restrições interface podem ser especificadas. A interface restrições também 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 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 where T : Employee { private class Node { private Node next; private

Visual C# Consolidado

365

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 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 where T : Employee, IEmployee, System.IComparable, 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 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(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 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{} 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.

Visual C# Consolidado

366

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 { void Add(List 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 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 item); public static void Notify(int i) { } Del m1 = new Del(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 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[] 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#

Visual C# Consolidado

367

private static void DoWork(float[] items) { } public static void TestStack() { Stack s = new Stack(); Stack.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 sender, U eventArgs); class Stack { public class StackEventArgs : System.EventArgs { } public event StackEventHandler stackEvent; protected virtual void OnStackChanged(StackEventArgs a) { stackEvent(this, a); } } class SampleClass { public void HandleStackChange(Stack stack, Stack.StackEventArgs args) { } } public static void Test() { Stack s = new Stack(); SampleClass o = new SampleClass(); s.stackEvent += o.HandleStackChange; }

COMO: Criar um bloco iterador para uma lista genérica (Guia de programação C#) Neste exemplo a genérica Classe Stack implementa o Interface IEnumerator 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 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 : IEnumerable { 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 implement IEnumerable allowing // a stack to be used in a foreach statement. public IEnumerator GetEnumerator() { for (int i = top; --i >= 0; ) { yield return values[i]; } } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } // Iterate from top to bottom. public IEnumerable TopToBottom { get { // Since we implement IEnumerable // and the default iteration is top to bottom, // just return the object. return this; } } // Iterate from bottom to top. public IEnumerable 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 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 s = new Stack(); 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 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 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 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 foreach (int n in s.TopN(7)) { System.Console.Write("{0} ", n); } System.Console.WriteLine(); } } }

Visual C# Consolidado

368

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 item); public void Notify(int i) { }

C# Del d1 = new Del(Notify);

Em C# 2.0, também é possível para declarar uma Delegar essa sintaxe simplificada usando: C# Del 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.

Visual C# Consolidado

369

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

Programação robusta 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

Visual C# Consolidado

370

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

Visual C# Consolidado

371

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 Spellverificaçã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); } } }

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

Visual C# Consolidado

372

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

Visual C# Consolidado

373

Você deve ter Excel instalado em seu sistema para este código seja executado corretamente. 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. 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

Visual C# Consolidado

374

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

4.

Se renda é mais de r$ 100,00 68,800 e em $143,500, o imposto é 28 por cento da quantidade sobre $68,800 mais $14,010.00.

5.

Se renda é mais de r$ 100,00 143,500 e em $311,950, o imposto é 33 por cento da 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. 2.

3.

Criar um novo projeto Visual C# Class Library chamado ExcelAddIn. 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. 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 && income 28400 && income 68800 && income 143500 && income 311950) {return 90514.50 + (.35 * (income 311950));} return 0; } [ComRegisterFunctionAttribute] public static void RegisterFunction(System.Type t) { Microsoft.Win32.Registry.ClassesRoot.CreateSubKey ("CLSID\\{"

Visual C# Consolidado

375

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

Visual C# Consolidado

376

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

Compilando o código

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# // compile with: /unsafe

Visual C# Consolidado

377

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

Visual C# Consolidado

378

Main(string[] args) { if (args.Length != 1) { System.Console.WriteLine("Usage : ReadFile "); 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,

Visual C# Consolidado

379

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#

Visual C# Consolidado

380

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#

Visual C# Consolidado

381

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.

Visual C# Consolidado

382

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 queue = new Queue(); 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

Visual C# Consolidado

383

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

Programação robusta 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.

Visual C# Consolidado

453

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

Programação robusta 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 My.Computer.FileSystem. 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.

Visual C# Consolidado

454

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

Programação robusta

Visual C# Consolidado

455

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

Visual C# Consolidado

456

Programação robusta 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

Visual C# Consolidado

457

security settings. fSecurity.RemoveAccessRule(new FileSystemAccessRule(account, rights, controlType)); // Set the new access settings. File.SetAccessControl(fileName, fSecurity); } } }

Compilando o código 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.

Visual C# Consolidado

458

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

Visual C# Consolidado

459

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.

Visual C# Consolidado

460

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

Visual C# Consolidado

461

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

Visual C# Consolidado

462

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 Ou1

Esta instância é maior que value. Oué 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!"));

Visual C# Consolidado

463

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

Este exemplo exibe True para o console. 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

Visual C# Consolidado

464

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

Este exemplo exibe True para o console. 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'));

Este exemplo exibe 2 para o console. 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'));

Este exemplo exibe 9 para o console. 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

Visual C# Consolidado

465

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

Visual C# Consolidado

466

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

Visual C# Consolidado

467

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.

Visual C# Consolidado

468

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); Console.WriteLine(MyStringBuilder);

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 substituilos com o caractere ponto de interrogação (?). C# StringBuilder MyStringBuilder = new StringBuilder("Hello World!"); MyStringBuilder.Replace('!', '?'); Console.WriteLine(MyStringBuilder);

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

Visual C# Consolidado

469

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.

Visual C# Consolidado

470

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

Visual C# Consolidado

471

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:

Visual C# Consolidado

472

•

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.

Visual C# Consolidado

473

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

Visual C# Consolidado

474

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.

Visual C# Consolidado

475

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

Visual C# Consolidado

476

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.

Visual C# Consolidado

477

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

Visual C# Consolidado

478

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:

Visual C# Consolidado

479

•

é 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 : IList, ICollection, IEnumerable, 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).

Visual C# Consolidado

480

•

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.

Visual C# Consolidado

481

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 dinosaurs = new List(); 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.

Visual C# Consolidado

482

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 Compatível com: 2.0

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 : IDictionary, ICollection, IEnumerable, 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)

Visual C# Consolidado

483

•

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 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 openWith = new Dictionary(); // 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

Visual C# Consolidado

484

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 kvp in openWith ) { Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value); } // To get the values alone, use the Values property. Dictionary.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.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.

Visual C# Consolidado

485

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 Compatível com: 2.0

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.

Visual C# Consolidado

486

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.

Visual C# Consolidado

487

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

Visual C# Consolidado

488

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

Visual C# Consolidado

489

// 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. _ Public Shared Sub Main(args() As String) Application.Run(New MyForm()) End Sub End Class

Compilando o código 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#

Visual C# Consolidado

490

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

Visual C# Consolidado

491

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.

Visual C# Consolidado

492

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

Visual C# Consolidado

493

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

Visual C# Consolidado

494

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.

Visual C# Consolidado

495

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,

Visual C# Consolidado

496

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

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:

Visual C# Consolidado

497

•

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 .

•

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 .

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

Visual C# Consolidado

498

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

No menu Build, clique em Configuration Manager. Em Active solution platform box, selecione a plataforma que você deseja direcionar a solução, ou selecione 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 1.

No menu Build, clique em Configuration Manager.

Visual C# Consolidado

499

2. 3.

Em a Active solution platform box, selecione . A Edit Solution Platforms Caixa de diálogo é aberta. 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.

Visual C# Consolidado

500

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

No menu Tools, escolha Options. 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ê: Escolhe Start (F5) a partir do Menu Debug.

o

Ouo

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

Visual C# Consolidado

501

1. 2.

No menu Tools, escolha Options. 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 1. 2.

No menu Tools, escolha Options. 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: 1.

No menu Project, clique em Properties.

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.

Visual C# Consolidado

502

2. 3. 4.

No menu Project, clique em Properties. 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 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. 2. 3. 4.

Em Solution Explorer, selecione a solução. No menu Project, clique em Properties. O A caixa de diálogo de páginas de Propriedades da Solução abre. Expanda o nó Common Properties, e clique em Startup Project. 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

Visual C# Consolidado

503

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

Na aba Dependencies , selecione um projeto a partir do menu suspenso Project. 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. 4.

Na aba Dependencies, selecione um projeto a partir do menu suspenso Project. 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

Visual C# Consolidado

504

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.

Visual C# Consolidado

505

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

Visual C# Consolidado

506

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

Visual C# Consolidado

507

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

Visual C# Consolidado

508

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.

Visual C# Consolidado

509

• o o

Suporte a novos recursos no SQL Server 2005, incluindo: Depuração de tipos de objetos de banco de dados gerenciado. 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

Visual C# Consolidado

510

•

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.

Visual C# Consolidado

511

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.

Visual C# Consolidado

512

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

Visual C# Consolidado

513

•

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 Tools for Office

•

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

Visual C# Consolidado

514

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 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 , selecione se a guia Debug ou, se o tipo de projeto é um site da Web, Start Options.

4. 5.

Na caixa de listagem Configuration, clique em Debug ou Release. 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 Debugger to launch

Description Especifica o depurador a ser executado, com as seguintes opções: Local Windows Debugger Remote Windows Debugger Web Service Debugger MPI Cluster Debugger

• • • •

Visual C# Consolidado

515

Command (Local Windows Debugger)

Especifica o comando para iniciar o programa que você está depurando na máquina local.

Remote Command (Remote Windows Debugger) Application Command (MPI Cluster Debugger)

O caminho para o .exe conforme ilustrado pelo computador remoto.

Especifica argumentos para o comando especificado acima. Command Arguments • (Local Windows Você pode usar os seguintes operadores de redirecionamento na Debugger e Remote caixa: Windows Debugger) < file Lê stdin do arquivo. Application Arguments (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 Debugger and Remote Windows Debugger)

Especifica a iniciar ou anexar para o aplicativo. A Configuração padrão é Não.

Remote Server Name (Remote Windows Debugger and MPI Cluster Debugger)

Especifica o nome de um computador (diferente do seu) no qual você deseja depurar um aplicativo ou um Nome do servidor Msvsmon. Você também pode selecionar isso a partir da caixa de diálogo Processes (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 Windows Debugger and MPI Cluster Debugger)

Permite que você alterne entre depuração local e remota. Especifique um nome de computador remoto na caixa Remote Server Name. 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

Visual C# Consolidado

516

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 Windows Debugger)

Especifica variáveis de ambiente para o programa que você está 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 ( variáveis de ambiente.

) elipse para editar

Merge Environment (Local Windows Debugger)

Determina se as variáveis especificadas na caixa Environment serão mescladas com o ambiente definido pelo sistema operado. A configuração padrão é Sim.

SQL Debugging (todos menos MPI Cluster Debugger)

Ativa a depuração de procedimentos SQL de seu aplicativo Visual C++. A configuração padrão é Não.

Pasta C/C++ (Categoria geral) Configuração

Descrição

Debug Information Format (/Z7, /Zd, Zi, /ZI)

Especifica o tipo de informações de depuração a serem criadas para o projeto. 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) Configuração Descriçã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) Configuração

Descrição

Generate Debug Info (/DEBUG)

Informa o vinculador para incluir informações da depuração, que terão o formato especificado por /Z7, /Zd, Zi, ou /ZI.

Generate Program

Especifique o nome de um arquivo PDB nesta caixa. Você deve

Visual C# Consolidado

517

Database File (/PDB:nome) selecionar ZI ou /Zi para formato de informações de depuração. Strip Private Symbols (/PDBSTRIPPED:filename)

Especifique o nome de um arquivo PDB nesta caixa se você não 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 (/MAP:nome)

Se você escolher gerar arquivo de mapa, você pode especificar o arquivo de mapa nesta caixa. Para obter mais informações consulte /MAP (Gerar Mapfile).

Map Exports (/MAPINFO:EXPORTS)

Inclui funções exportadas no arquivo de mapa. A configuração padrão é Não. Para obter mais informações consulte /MAPINFO (inclui informações em Mapfile).

Debuggable Assembly (/ASSEMBLYDEBUG)

Especifica configurações para a opção Linker /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). • . • 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: 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

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

Visual C# Consolidado

518

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 Configuração

Descriçã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.

Visual C# Consolidado

519

Especifica argumentos de linha de comando para o programa a ser Argumentos da 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 trabalho

Especifica a pasta de trabalho do programa que está sendo depurado. No Visual Basic, a pasta de trabalho é o diretório de que aplicativo é iniciado, \bin, por padrão.

Usar máquina remota

Quando a caixa de seleção estiver marcada, a depuração remota é ativado. 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 código não gerenciado

Permite a você depurar chamadas para código nativo (não gerenciado) de Win32 de seu aplicativo gerenciado. Isso tem o mesmo efeito de que selecionar misto para tipo de depurador em um projeto Visual C++.

Depuração do SQL Server

Permite a depuração de objetos de banco de dados do SQL Server.

Guia Compilar: Pressione botão Opções avançadas de compilação Configuração

Descrição

Ativar otimizações

Esta opção deve ser desmarcada. Otimização faz com que o código que é 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 informações de depuração

Definidos por padrão nas versões de lançamento e de depuração, esta configuração (equivalente a opção do compilador /debug) cria informações da 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 classe de depuração. Com esse símbolo definido, métodos de classe de DEBUG 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 da classe Rastrear. Com esse símbolo definido, os métodos de classe de Trace 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.

Visual C# Consolidado

520

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 , 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 Este tópico se aplica a: 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

Visual C# Consolidado

521

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.

Visual C# Consolidado

522

•

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:

Visual C# Consolidado

523

•

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

Visual C# Consolidado

524

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

Abra a janela Immediate do depurador. 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.

Visual C# Consolidado

525

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

Visual C# Consolidado

526

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

Você deve sempre definir esta opção para Yes (/DEBUG) para criar arquivos necessários para depuração e símbolos de depuração. Quando o aplicativo 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 Property Pages. Para obter mais informações, consulte Configurações para Debug e Release.

Visual C# Consolidado

527

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

Abra o projeto no Visual Studio.

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,

Visual C# Consolidado

528

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

Visual C# Consolidado

529

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.

Visual C# Consolidado

530

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 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 Properties, abra o nó Common Properties e selecione Startup Project.

7. 8. 9.

Clique em Multiple Startup Projects. Em Multiple Startup Projects, vá para a coluna Action e defina a ação como Start para ambos os projetos. Clique em OK para fechar a janela Solution 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.

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

Visual C# Consolidado

531

6. 7.

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

No menu Open, clique em File e selecione Project. Na caixa de diálogo Open Project, clique na seta Files of type, e selecione Executable Files. 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.

Visual C# Consolidado

532

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 Este tópico se aplica a: 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. 2.

Insira seu cartão Code Center Premium no leitor SmartCard conectado ao seu computador. Insira o Code Center Premium Welcome Kit CD na unidade de CD-ROM.

Visual C# Consolidado

533

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

Abra o projeto no Visual Studio.

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 Visual C# Consolidado

534

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

Na coluna Name, clique duas vezes em SecureSourceLocalDirectory. 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 Este tópico se aplica a: 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.

Visual C# Consolidado

535

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

Se a zona que você escolher for (Custom), selecione correto as configurações personalizadas na coluna Setting da grade Permissions. 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. 3.

Na caixa de diálogo Exception Assistant em Actions, clique em Add Permission to the Project. A caixa de diálogo Restart Debug será exibida. Se você desejar reiniciar a sessão de depuração com a nova permissão, clique em

o

Yes. Se você não desejar reiniciar ainda, clique em No.

o

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

Visual C# Consolidado

536

Padrão

Não

Não

Não

Não

Não

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

Abra a solução que contém o aplicativo paralelo no Visual Studio. 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)

Visual C# Consolidado

537

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. 13. A partir do menu Tools, escolha Options. 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: Este tópico se aplica a: 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.

Visual C# Consolidado

538

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) OuNo 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 Este tópico se aplica a: Visual Studio Edition

Visual Basic

Visual C# Consolidado

C#

C++

J#

539

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.

Visual C# Consolidado

540

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

5.

Após navegar até {449EC4CC-30D2-4032-9256-EE18EB41B62B}, procure na coluna Name, e encontre a chave CLRVersionForDebugging. 1.

6. 7.

Se a chave não existir, clique com o botão direito do mouse em {449EC4CC-30D24032-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.

Clique duas vezes em CLRVersionForDebugging. 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á

Visual C# Consolidado

541

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.

Visual C# Consolidado

542

•

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

Visual C# Consolidado

545

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 System.Diagnostics.Debug.Assert(System.Boolean).

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:

Visual C# Consolidado

546

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

3. 4. 5.

Para Visual Basic, Visual C# ou Visual J#, selecione a Windows., em seguida, marque Windows Application no painel Templates. Para Visual C++, selecione o CLR.

No painel Templates, selecione Windows Application. Na caixa Name, dê ao projeto um nome exclusivo (por exemplo, Walkthrough_SimpleDebug). 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

Visual C# Consolidado

547

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: ' 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!";

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

No menu Debug, escolha Windows, em seguida Watch, e clique em Watch1. 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

Visual C# Consolidado

548

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# textBox1.set_Text("Button was clicked!"); // C++ textBox1->Text = "Button was clicked!";

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

Visual C# Consolidado

549

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

A partir do menu Tools, escolha Options.

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.

Visual C# Consolidado

550

- 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 Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

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: Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

Express

Não

Não

Nativo

Não

Padrão

Não

Não

Nativo

Não

Visual C# Consolidado

551

Pro / Team

Não

Não

Nativo

Não

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

Visual C# Consolidado

552

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 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 Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

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

Visual C# Consolidado

555

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 Segurança do Depurador Outros recursos Depuração de código nativo HOW TO: depurar código assembly embutido Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

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

Observação As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings (Importar e Exportar Configurações) no menu Tools (Ferramentas). Para obter mais informações, consulte Configurações do Visual Studio. 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 Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

Express

Não

Não

Nativo

Não

Visual C# Consolidado

556

Padrão

Não

Não

Nativo

Não

Pro / Team

Não

Não

Nativo

Não

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. Seções relacionadas 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. Depuração de código nativo Aborda alguns problemas comuns de depuração e técnicas para aplicativos C e C++. Segurança do Depurador Descreve as práticas recomendadas para segurança depuração.

Técnicas de depuração MFC Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

Express

Não

Não

Nativo

Não

Padrão

Não

Não

Nativo

Não

Visual C# Consolidado

557

Pro / Team

Não

Não

Nativo

Não

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. Seções relacionadas 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++ Aborda alguns problemas comuns de depuração e técnicas para aplicativos C e C++. Segurança do Depurador Fornece recomendações para depuração mais seguro.

Técnicas de depuração CRT Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

Express

Não

Não

Nativo

Não

Visual C# Consolidado

558

Padrão

Não

Não

Nativo

Não

Pro / Team

Não

Não

Nativo

Não

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. Seções relacionadas Depuração de código nativo Aborda alguns problemas comuns de depuração e técnicas para aplicativos C e C++. Segurança do Depurador Fornece recomendações para depuração mais seguro.

Depuração Native FAQs do código Este tópico se aplica a: Visual Studio Edition

Visual Basic

Visual C# Consolidado

C#

C++

J#

559

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

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 Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

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 Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

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

Visual C# Consolidado

560

Observação As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings (Importar e Exportar Configurações) no menu Tools (Ferramentas). Para obter mais informações, consulte Configurações do Visual Studio. Quando você depurar uma DLL, você pode iniciar a depuração de: O projeto usado para criar o executável que chama a DLL.

•

OuO 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 Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

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

Visual C# Consolidado

561

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

Visual C# Consolidado

562

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. Seções relacionadas 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 Descreve as configurações e comportamentos padrão dos projetos de Serviços da Web do 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: Descreve as configurações e comportamentos padrão dos projetos de Serviços da Web do 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 Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

Visual Web Developer

Express

Não

Não

Não

Não

Não

Visual C# Consolidado

563

Padrão

Não

Não

Não

Não

Não

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. Seções relacionadas 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

Visual C# Consolidado

564

•

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#

Visual C# Consolidado

565

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

Emitir a saída de rastreamento. 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#

Visual C# Consolidado

566

System.Diagnostics.Trace.Listeners.Add(myListener);

- ou o

Se você não desejar a escuta para receber a saída de rastreamento, não adicionelo à 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

Visual C# Consolidado

567

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.

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. 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(); // 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.TraceEvent(TraceEventType.Error, 4, "Error message."); 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

Visual C# Consolidado

568

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

Visual C# Consolidado

569

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.

Visual C# Consolidado

570

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

# Definir Trace

Ativa o rastreamento

# undefine Trace

Desativa o rastreamento

# Defina debug

Ativa a depuração

# undefine Debug

Desativa depuração

C#

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

Visual C# Consolidado

571

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.TraceEvent(TraceEventType.Error, 4, "Error message."); mySource.TraceInformation("Informational 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.

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. using System; using System.Diagnostics; using System.Threading; namespace TraceSourceApp { class Program { private static TraceSource mySource = new TraceSource("TraceSourceApp"); static void 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 //

Visual C# Consolidado

572

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."); 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.TraceEvent(TraceEventType.Error, 4, "Error message."); mySource.TraceInformation("Informational 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 {}., 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

Visual C# Consolidado

573

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

Visual C# Consolidado

574

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

Adicionar as instruções de rastreamento ao código do aplicativo. 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:

Visual C# Consolidado

575

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.

Visual C# Consolidado

576

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

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:

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 marca, mas antes da 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

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:

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

Visual C# Consolidado

577

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.

13.

No menu Debug, clique em Stop Debugging.

Visual C# Consolidado

578

Para anexar-se ao XML Web service para depuração 1. 2.

No Visual Studio, você pode anexar o depurador a um processo em execução. O procedimento a seguir mostra como fazer isso. 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. 3.

No menu Debug, selecione Start Without Debugging. O XML Web service inicia a execução no Internet Explorer, mas o depurador não está conectado.

4. 5.

No menu Debug, selecione Attach to Process. Você também pode clicar emAttach to Process no menu Tools. 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.

7.

Clique no botão Attach. 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.

Visual C# Consolidado

579

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

3. 4. 5.

Para Visual Basic, Visual C# ou Visual J#, selecione a Windows., em seguida, marque Windows Application no painel Templates. Para Visual C++, selecione o CLR.

No painel Templates, selecione Windows Application. Na caixa Name, dê ao projeto um nome exclusivo (por exemplo, Walkthrough_SimpleDebug). 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: ' 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!";

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

Visual C# Consolidado

580

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

No menu Debug, escolha Windows, em seguida Watch, e clique em Watch1. 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# textBox1.set_Text("Button was clicked!"); // C++ textBox1->Text = "Button was clicked!";

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

No painel Available Processes, localize o nome do processo (Walkthrough_SimpleDebug.exe) na coluna Process e clique nele. Clique no botão Attach.

Visual C# Consolidado

581

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

Standard

Não

Não

Não

Não

Não

Pro / Team

Sim

Sim

Sim

Sim

Sim

Este exemplo mostra como depurar uma função table-valued definida pelo usuário SQL CLR (UDF). Observação As caixas de diálogo e comandos de menu que você vê podem diferir daquelas descritas na Ajuda 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.

6.

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. Experimente recursos de depuração diferentes.

Visual C# Consolidado

582

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

Clique em Continue novamente para concluir a depuração da função. 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 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()); } }

Este é o script de teste que chama a função. 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 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

Standard

Não

Não

Não

Não

Não

Pro / Team

Sim

Sim

Sim

Sim

Sim

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

Visual C# Consolidado

590

•

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 Este tópico se aplica a: Visual Studio Edition

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

Sim

Sim

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 Import and Export Settings no menu Tools. Para obter mais informações, consulte Configurações Visual Studio. 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.

Visual C# Consolidado

591

4.

5.

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.

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

Experimente recursos de depuração diferentes. 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. 8.

Depure o disparador até que você saia de volta ao procedimento armazenado, e continue até o fim.

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

Standard

Não

Não

Não

Não

Não

Pro/Team

Sim

Sim

Sim

Sim

Sim

Visual C# Consolidado

592

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 TSQL, 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 1.

Em um novo projeto do SQL Server, estabeleça uma conexão com o banco de dados de 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 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. 2.

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

6.

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

Visual C# Consolidado

593

Este tópico se aplica a: Visual Studio Edition

Visual Basic

C#

C++

J#

Visual Web Developer

Express

Não

Não

Não

Não

Não

Standard

Não

Não

Não

Não

Não

Pro/Team

Sim

Sim

Sim

Sim

Sim

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 Import and Export Settings no menu Tools. Para obter mais informações, consulte Configurações Visual Studio. Para depurar um procedimento armazenado T-SQL 1.

Em um novo projeto do SQL Server, estabeleça uma conexão com o banco de dados de 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.

Visual C# Consolidado

594

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

5. 6. 5.

Você pode editar os valores das variáveis na janela Watch também.

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. No menu Debug, clique em Continue.

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)

Visual C# Consolidado

595

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/enus/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:

Visual C# Consolidado

596

•

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

Visual C# Consolidado

597

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 corporativa

Definida pelos administradores da empresa que definir a diretiva para domínios da empresa.

Diretiva da máquina

Definida pelos administradores máquina que definir a diretiva para um computador.

Diretiva de usuário Definido por usuários que definir a diretiva para uma conta de logon único. Diretiva de domínio de aplicativo

Definido pelo host do tempo de execução (qualquer aplicativo que hospeda o Common Language Runtime) para definir diretiva tempo carregar-. Este nível 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.

Visual C# Consolidado

598

•

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

Visual C# Consolidado

599

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 aplicativo

Use este assistente para identificar um aplicativo pelas informações Editor ou nome forte e Aumentar nível do aplicativo de confiança.

Ajustar configurações de segurança

Use este assistente para aumentar ou diminuir permissões a conjuntos de módulos (assemblies) proveniente de uma das seguintes zonas: Meu computador, intranet local, Internet, sites confiáveis e sites não confiáveis.

Criar um pacote de implantação

Use este assistente para criar um pacote Windows Installer para implantar a 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

Visual C# Consolidado

600

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.

Visual C# Consolidado

601

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.

Visual C# Consolidado

602

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

Visual C# Consolidado

603

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

Visual C# Consolidado

604

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

Criar entropia aleatório. Chame o método estático Protect Ao passar uma matriz de bytes para criptografar, a entropia, e o escopo proteção dados. Gravar os dados criptografados para um arquivo ou fluxo.

Para descriptografar dados de um arquivo ou transmitir usando proteção de dados 1. 2.

Ler os dados criptografados de um arquivo ou fluxo. 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

Visual C# Consolidado

605

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

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 elementos e XmlSchemaImport, XmlSchemaInclude a ,

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.

Visual C# Consolidado

855

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 DataSet

Quando se sincronizar um 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ódigofonte XML é não crítica.

Preservação do elemento ordenação no código-fonte XML é essencial.

Espaço em branco entre elementos e formatação não precise ser preservado no código-fonte XML.

Espaço em branco e formatação manutenção no código-fonte XML é crítica.

Visual C# Consolidado

856

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

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.

Visual C# Consolidado

857

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 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. Para restringir o acesso usando uma URL

Visual C# Consolidado

858

•

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. Você estiver trabalhando em um ambiente totalmente confiáveis:

o

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.

Visual C# Consolidado

859

OuSe seu aplicativo exigir alguns acesso aos recursos, solicitar evidência do chamador. Use o XmlSecureResolver para resolver recursos XML A XmlUrlResolver classe é o resolvedor padrão para todas as classes no espaço para nome 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.

Visual C# Consolidado

860

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

Visual C# Consolidado

861

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

Visual C# Consolidado

862

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

Visual C# Consolidado

863

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 2001-02-27T11:13:23

Esse código Converte a seqüência para o DateTime formato: C#

Visual C# Consolidado

864

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

Esse código converte o Int32: em um String C# Int32 vInt32=-2147483648; writer.WriteElementString("TestInt32",XmlConvert.ToString(vInt32));

Visual C# Consolidado

865

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.

Visual C# Consolidado

866

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 online. 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 infraestrutura 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ê

Visual C# Consolidado

867

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. Seções relacionadas Programação na Web com XML Web Services

Visual C# Consolidado

868

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.

Visual C# Consolidado

869

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. Seções relacionadas Programação na Web com XML Web Services 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. Usando cabeçalhos SOAP 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

Visual C# Consolidado

870

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. Usando cabeçalhos SOAP

Visual C# Consolidado

871

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. Passo-a-passo: Personalizando a Geração de Descrições de Serviços e Classes Proxy 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. Seções relacionadas 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.

Visual C# Consolidado

872

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.

Visual C# Consolidado

873

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

Visual C# Consolidado

874

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:///apppath/StockServices.asmx. You could test this service by entering this HTTP-GET request in the browser's address bar: http:///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 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 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.

Visual C# Consolidado

875

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:///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: 74.5

Para testar um serviço da Web em um navegador usando HTTP-POST 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. 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# 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 Imports System.Web.Services Public Class Math Inherits WebService _ Public Function Add(num1 As Integer, num2 As Integer) As Integer Return num1 + num2 End Function _ 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: =

Visual C# Consolidado

876

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.

3.

Nome ='num1'

O nome do parâmetro método Serviço da Web. Adicionar quantos controles de 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 = enviar

Adicionar um botão Enviar para você pode enviar os dados de volta para o método serviço Web.

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

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.

Visual C# Consolidado

877

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.

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.

Visual C# Consolidado

878

webservicename.asmx O nome do arquivo.asmx para o 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&...¶meternamen=valuen

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

Visual C# Consolidado

879

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.

4.

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

Visual C# Consolidado

880

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

Visual C# Consolidado

881

•

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# public class Service1 : System.Web.Services.WebService { [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 Visual C# Consolidado

882

Use a propriedade Description do atributo WebMethod , como mostrado abaixo:

•

' Visual Basic Public Class Service1 Inherits System.Web.Services.WebService _ 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# public class Service1 : System.Web.Services.WebService { [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# public class Service1 : System.Web.Services.WebService { [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" double double 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: double

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# using System.EnterpriseServices;

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

Visual C# Consolidado

884

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 depurador

Este método inicia o navegador padrão e carrega a página inicial especificada. 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 depurador

Esse método possibilita que você possa executar seu código como ele normalmente 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 navegador

Este método compila o projeto e abre uma página da Web escolhida no Solution 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. 2.

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

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. No menu Debug, clique em Start Without Debugging. 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.

Visual C# Consolidado

885

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.

Visual C# Consolidado

886

3. 4. 5. 6.

Clique no ícone ao lado da caixa suspensa Connect to: para abrir a caixa de diálogo Open Web Site. Na caixa Open Web Site, selecione a localidade para a qual você deseja copiar o projeto. Usando os ícones de seta, selecione arquivos do site da Web de origem para copiá-los para o site da Web remoto. 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

Visual C# Consolidado

887

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

Visual C# Consolidado

888

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

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.

Visual C# Consolidado

889

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

Visual C# Consolidado

1035

(this.relatedDesigner.createdTimer != null) { this.host.DestroyComponent( this.relatedDesigner.createdTimer); this.relatedDesigner.createdTimer = null; 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] [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; } }

Anexar o componente a sua ToolboxItem Classe usando ToolboxItemAttribute. C# [DesignerAttribute(typeof(DemoControlDesigner))] [ToolboxItem(typeof(DemoToolboxItem))] public class DemoControl : Label {

Compilando o código 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.

Visual C# Consolidado

1036

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

Adicione uma referência ao conjunto System.Design. 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.

Visual C# Consolidado

1037

•

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; // // // // Help Label offers an extender property called // "HelpText". It monitors the active control // and displays the help text for the active control. // // // [ ProvideProperty("HelpText",typeof(Control)), Designer(typeof(HelpLabel.HelpLabelDesigner)) ] public class HelpLabel : Control, System.ComponentModel.IExtenderProvider { /// /// Required designer variable. /// private System.ComponentModel.Container components; private Hashtable helpTexts; private System.Windows.Forms.Control activeControl; // // // // Creates a new help label object. // // // public HelpLabel() { // // Required for Windows Form Designer support // InitializeComponent(); helpTexts = new Hashtable(); } /// /// Clean up any resources being used. /// protected override void Dispose(bool disposing) { if (disposing) { components.Dispose(); } base.Dispose(disposing); } /// /// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// private void InitializeComponent() { this.components = new System.ComponentModel.Container (); this.BackColor = System.Drawing.SystemColors.Info; this.ForeColor = System.Drawing.SystemColors.InfoText; this.TabStop = false; } // // // // 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. // // // [ Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) ] public override string Text { get { return base.Text; } set { base.Text = value; } } // // // // 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). // // // bool IExtenderProvider.CanExtend(object target) { if (target is Control && !(target is HelpLabel)) { return true; } return false; } // // // // 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. // // // [ DefaultValue(""), ] public string GetHelpText(Control control) { string text = (string)helpTexts[control]; if (text == null) { text = string.Empty; } return text; } // // // // This is an event handler that responds to the OnControlEnter // event. We attach this to each control we are providing help // text for. // // // private void OnControlEnter(object sender, EventArgs e) { activeControl = (Control)sender; Invalidate(); } // // // // This is an event handler that responds to the OnControlLeave // event. We attach this to each control we are providing help // text for. // // // private void OnControlLeave(object sender, EventArgs e) { if (sender == activeControl) { activeControl = null; Invalidate(); } } // // // // This is the extended property for the HelpText property. // // // public void SetHelpText(Control control, string value) { if (value == null) { value = string.Empty; } if (value.Length == 0) {

Visual C# Consolidado

1038

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(); } } // // // // Overrides Control.OnPaint. Here we draw our // label. // // // 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(); } } } // // // Returns true if the backColor should be persisted in code gen. We // override this because we change the default back color. // // // true if the backColor should be persisted. // // // public bool ShouldSerializeBackColor() { return(!BackColor.Equals(SystemColors.Info)); } // // // Returns true if the foreColor should be persisted in code gen. We // override this because we change the default foreground color. // // // true if the foreColor should be persisted. // // // public bool ShouldSerializeForeColor() { return(!ForeColor.Equals(SystemColors.InfoText)); } // // // // 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. // // // [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")] public class HelpLabelDesigner : System.Windows.Forms.Design.ControlDesigner { private bool trackSelection = true; /// /// 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. /// 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); } } // // // // 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. // // // 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); } // // // // 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. // // // 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) {

Visual C# Consolidado

1039

MessageBox.Show("You have just invoked a sample verb. Normally, this would do something interesting."); } // // // // Our handler for the selection change event. Here we update the active control within // the help label. // // // 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 } /// /// This is a helper method that, given a selection service, will update the active control /// of our help label with the currently active selection. /// /// 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 { /// /// Required designer variable. /// 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(); } /// /// Clean up any resources being used. /// protected override void Dispose(bool disposing) { if (disposing) { components.Dispose(); } base.Dispose(disposing); } /// /// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// 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 = ""; 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); } ///

Visual C# Consolidado

1040

/// The main entry point for the application. /// [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# 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

Visual C# Consolidado

1041

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. [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "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);

Visual C# Consolidado

1042

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

Visual C# Consolidado

1043

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

Visual C# Consolidado

1044

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

Visual C# Consolidado

1045

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

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

Visual C# Consolidado

1046

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

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) { this.changeService.ComponentChanged += new ComponentChangedEventHandler( ChangeService_ComponentChanged); this.changeService.ComponentAdded += new ComponentEventHandler( ChangeService_ComponentAdded); this.changeService.ComponentRemoved += new ComponentEventHandler( changeService_ComponentRemoved); }

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

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) { this.eventService.ActiveDesignerChanged -= new ActiveDesignerEventHandler(

Visual C# Consolidado

1047

eventService_ActiveDesignerChanged); } if (this.selectionService != null) { this.selectionService.SelectionChanged -= new EventHandler( selectionService_SelectionChanged); } } 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"); } }

Compilando o código 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: 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

Visual C# Consolidado

1048

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

Visual C# Consolidado

1049

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. Compilando o código 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: 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.

Visual C# Consolidado

1050

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

Definir uma classe que deriva de TypeConverter.

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.

Visual C# Consolidado

1051

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 =

Visual C# Consolidado

1052

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 construtorcódigo de inicialização 1.

Definir uma classe que deriva de TypeConverter.

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

Visual C# Consolidado

1053

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

Compilando o código •

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. Compilando o código •

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

Visual C# Consolidado

1054

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# using System; using System.Collections; using System.ComponentModel; using System.ComponentModel.Design; using System.Drawing; using System.Drawing.Design; using System.Windows.Forms; using System.Windows.Forms.Design; using System.Windows.Forms.Design.Behavior; public class Form1 : Form { private DemoControl demoControl1; 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))]

Visual C# Consolidado

1055

public class DemoControl : UserControl { private System.ComponentModel.IContainer components = null; public DemoControl() { InitializeComponent(); } protected override void Dispose(bool disposing) { if (disposing && (components != null)) { components.Dispose(); } base.Dispose(disposing); } private void 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. [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "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();

Visual C# Consolidado

1056

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

Visual C# Consolidado

1057

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 = this.behaviorService.ControlRectInAdornerWindow(this.relatedControl); Rectangle boundsVal = new 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. // Doubleclicking 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

Visual C# Consolidado

1058

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

Visual C# Consolidado

1059

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

Visual C# Consolidado

1060

this.behaviorService.ControlRectInAdornerWindow(this.relatedControl); Rectangle boundsVal = new 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, 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); }

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

Visual C# Consolidado

1061

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,

Visual C# Consolidado

1062

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 Initialize(IComponent component) { base.Initialize(component); // Connect to various designer services. InitializeServices(); // Initialize adorners. this.InitializeMarginAndPaddingAdorner(); this.InitializeAnchorAdorner(); }

C#

Visual C# Consolidado

1063

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

Compilando o código 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: 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#

Visual C# Consolidado

1064

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

Visual C# Consolidado

1065

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

Visual C# Consolidado

1066

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

Visual C# Consolidado

1067

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

Visual C# Consolidado

1068

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.Collections; using System.ComponentModel; using 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); } /// /// Clean up any resources being used. /// 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 /// /// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// 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

Visual C# Consolidado

1069

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 /// /// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// 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# using System; using System.Collections; using System.ComponentModel; using System.ComponentModel.Design; using System.Diagnostics; using System.Windows.Forms; using System.Windows.Forms.Design; namespace MarqueeControlLibrary.Design { [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "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(

Visual C# Consolidado

1070

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# using System; using System.Collections; using System.ComponentModel; using System.ComponentModel.Design; using System.Diagnostics; using System.Drawing.Design; using System.Windows.Forms; using System.Windows.Forms.Design; namespace MarqueeControlLibrary.Design { [ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", ToolboxItemFilterType.Require)] [ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", ToolboxItemFilterType.Require)] [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "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(); } } }

Compilando o código

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

Visual C# Consolidado

1071

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 ///////////////////////////////////////////////////////////////// [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "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; } } } ///////////////////////////////////////////////////////////////// // DesignerActionListderived 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

Visual C# Consolidado

1072

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ê precisará recriar o projeto de controle. Além disso, se não houver outro projeto Windows Forms 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# 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)) {

Visual C# Consolidado

1073

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. [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "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() {

Visual C# Consolidado

1074

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

Visual C# Consolidado

1075

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

Visual C# Consolidado

1076

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

Visual C# Consolidado

1077

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

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

C#

Visual C# Consolidado

1078

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

Compilando o código 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.

Visual C# Consolidado

1079

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.

Visual C# Consolidado

1080

O Excel Usando Explicações Passo-a-passo Walkthroughs fornecem instruções passo a passo para cenários comuns e são um bom lugar para começar aprendendo sobre Microsoft Visual Studio 2005 Tools for the Microsoft Office System. Orientações as seguir demonstram vários tipos básicos de tarefas: automatizar o Microsoft Office Excel 2003, executar análise de dados, trabalhar com controles, soluções, implantação e definindo a segurança.

Coleta de dados usando um formulário do Windows Walkthrough: Essa explicação passo a passo demonstra como abrir um formulário Windows de um planilha do Microsoft Office Excel 2003, coletar informações do usuário, e gravar essas informações em uma célula da planilha. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Excel Observação

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

Criar um projeto de pasta de trabalho do Excel com o nome WinFormInput. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o WinFormInput projeto para Solution Explorer. Adicionar um controle NamedRange para a planilha

Para adicionar um intervalo nomeado para Sheet1 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.

Visual C# Consolidado

1081

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 manipuladores de eventos em Ferramentas do Visual Studio do Office:.

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.

Visual C# Consolidado

1082

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. Para testar sua pasta de trabalho 5.

Pressione F5 para executar o projeto.

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

Implantando o projeto. Para obter mais informações, consulte Como: Implantar arquivos de solução usando o Publish Wizard.

Alterando planilha formatação usando controles CheckBox Walkthrough: Essa explicação passo a passo mostra os fundamentos básicos do uso caixas de seleção em um planilha do Microsoft Office Excel 2003 para alterar a formatação. Você usará Microsoft Visual Studio 2005 Tools for the Microsoft Office System para criar e adicionar código ao seu projeto. Para ver o resultado como uma amostra completa, consulte Exemplo do Excel de controles. Durante este explicação passo a passo, você aprenderá como: •

Adicione texto e controles para uma planilha.

•

Formate o texto quando uma opção é selecionada.

•

Testar seu projeto. Observação

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

Visual C# Consolidado

1083

Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

Microsoft Office Excel 2003. Criando o projeto

Nesta etapa, você irá criar um projeto usando Visual Studio Tools for Office pasta de trabalho do Excel. Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Excel Formatting. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel Formatting projeto para Solution Explorer. Adicionar texto e controles a planilha

Para essa explicação passo a passo, você precisará três CheckBox controles e algum texto em um NamedRange controle. Para adicionar três caixas de seleção 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. 12. 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

13. Arraste uma segunda caixa de seleção ou próxima célula B4 e alterar as seguintes propriedades: Propriedade

Value (Valor)

Name

applyItalicFont

Text

Itálico

14. Arraste uma caixa de seleção terceira ou próxima célula B6 e alterar as seguintes propriedades: Propriedade

Value (Valor)

Name

applyUnderlineFont

Visual C# Consolidado

1084

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

Na guia Excel Controls da caixa de ferramentas, arraste um NamedRange controle à célula B9.

7.

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.

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

Value (Valor)

Name

textFont

Value2

Clique em uma caixa de seleção para alterar a formatação de texto.

Em seguida, escreva o código para formatar o texto quando uma opção é selecionada. Formatação quando a opção um texto é selecionado Você nesta seção, vai escrever código para que quando o usuário seleciona uma opção de formatação, o formato do texto na planilha for alterado.

Para alterar a formatação quando uma caixa de seleção é marcada 6.

Clique com o botão direito do mouse Sheet1 e clique View Code no menu de atalho

7.

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

8.

Adicione o seguinte código ao manipulador Click de eventos da caixa applyItalicFont de seleção: C#

Visual C# Consolidado

1085

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 evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C# this.applyBoldFont.Click += new EventHandler(applyBoldFont_Click); this.applyItalicFont.Click += new EventHandler(applyItalicFont_Click); this.applyUnderlineFont.Click += new EventHandler(applyUnderlineFont_Click);

Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se que o texto está formatado corretamente quando você marca ou desmarca uma caixa de seleção.

Para testar sua pasta de trabalho 4.

Pressione F5 para executar o projeto.

5.

Marque ou desmarque uma caixa de seleção.

6.

Confirme que o texto está formatado corretamente. Próximas etapas

Essa explicação passo a passo mostra as noções básicas de usando caixas de seleção e formatar texto em planilhas do Excel 2003. Aqui estão algumas tarefas que podem vie em seguida: •

Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Usando um botão para preencher uma caixa de texto. Para obter mais informações, consulte Exibindo texto em uma caixa de texto em uma planilha usando um botão Walkthrough:.

Exibindo texto em uma caixa de texto em uma planilha usando um botão Walkthrough: Essa explicação passo a passo mostra os fundamentos básicos do uso botões e caixas de texto em planilhas Microsoft Office Excel 2003, e como criar projetos Excel usando Microsoft Visual Studio 2005 Tools for the Microsoft Office System. Para ver o resultado como uma amostra completa, consulte Exemplo do Excel de controles. Durante este explicação passo a passo, você aprenderá como:

Visual C# Consolidado

1086

•

Adicionar controles a uma planilha.

•

Preencher uma caixa de texto quando um botão é clicado.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

Excel. Criando o projeto

Nesta etapa, você irá criar um projeto usando Visual Studio Tools for Office pasta de trabalho do Excel.

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Excel Button. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel Button projeto para Solution Explorer. Adicionar controles a planilha

Para essa explicação passo a passo, será necessário um botão e uma caixa de texto na primeira planilha.

Para adicionar um botão e uma caixa de texto 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

8.

No menu View, selecione Properties Window.

9.

Certifique-que TextBox1 está visível na caixa Properties drop-down janela e alterar a Name propriedade da caixa de texto para displayText.

10. Arraste um Button controle até Sheet1 e alterar as seguintes propriedades: Propriedade

Value (Valor)

Name

insertText

Visual C# Consolidado

1087

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

Na Solution Explorer, clique com o botão direito do mouse Sheet1 e, em seguida clique View Code no menu de atalho.

5.

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

6.

Em C#, adicione um manipulador de eventos para o Startup evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C# this.insertText.Click += new EventHandler(insertText_Click);

Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se que a mensagem Hello World! aparece na caixa de texto quando você clica no botão. Para testar sua pasta de trabalho 4.

Pressione F5 para executar o projeto.

5.

Clique no botão.

6.

Confirme que Hello World! aparece na caixa de texto. Próximas etapas

Essa explicação passo a passo mostra os fundamentos básicos do uso botões e caixas de texto em planilhas do Excel. Aqui estão algumas tarefas que podem vie em seguida: •

Implantando o projeto. Para obter mais informações, consulte Como: Implantar arquivos de solução usando o Publish Wizard.

•

Usar caixas de seleção para alterar a formatação. Para obter mais informações, consulte Alterando planilha formatação usando controles CheckBox Walkthrough:.

Programação contra eventos de um controle NamedRange Walkthrough: Essa explicação passo a passo demonstra como adicionar um NamedRange controle a um planilha do Microsoft Office Excel 2003 e programa contra seus eventos usando Microsoft Visual Studio 2005 Tools for the Microsoft Office System.

Visual C# Consolidado

1088

Durante este explicação passo a passo, você aprenderá como: •

Adicionar um NamedRange controle para uma planilha.

•

Programa contra NamedRange Eventos de controle.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

Microsoft Office Excel 2003. Criando o projeto

Nesta etapa, você irá criar pasta de trabalho Excel usando Visual Studio Tools for Office Um do projeto.

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Named Range Events. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Named Range Events projeto para Solution Explorer. Adicionar texto e pipes intervalos para a planilha

Porque controles host são estendidos objetos do Office, você poderá adicioná-los para o documento em da mesma maneira, você adicionar o objeto nativo. Por exemplo, você pode adicionar um controle Excel NamedRange a uma planilha ao abrir o Insert menu apontando para Name, e escolher Define. Você também pode adicionar um NamedRange controle, arrastando-a partir para a planilha. o Toolbox 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 studio, com Sheet1 exibido.

9.

Na guia Excel Controls da caixa de ferramentas, arraste um NamedRange controle à célula A1 no Sheet1. A Add NamedRange Control caixa de diálogo será exibida.

Visual C# Consolidado

1089

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. 13. Verificar que $B$3 aparece na caixa de texto editável, e essa célula B3 estiver selecionada. Se não estiver, clique em Célula B3 para selecioná-lo. 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 é 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; }

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

Visual C# Consolidado

1090

Adicionar código para responder ao evento de alteração

Para inserir texto em namedRange2 com base no evento Change •

Adicione código para o NamedRange1_Change manipulador de eventos é semelhante ao seguinte: C# private void namedRange1_Change(Microsoft.Office.Interop.Excel.Range Target) { this.namedRange2.Value2 = "The Change event occurred."; this.namedRange2.Font.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.Blue); this.namedRange2.Font.Italic = false; }

Observação Como duas vezes em uma célula em um intervalo do Excel entra no modo de edição, um Change evento ocorre quando a seleção é movida fora do intervalo mesmo que nenhuma alteração ao texto ocorreu. Adicionar código para responder ao evento SelectionChange

Para inserir texto em namedRange2 com base no evento SelectionChange •

Adicione código para o NamedRange1_SelectionChange manipulador de eventos é semelhante ao seguinte: C# private void namedRange1_SelectionChange(Microsoft.Office.Interop.Excel.Range Target) { this.namedRange2.Value2 = "The SelectionChange event occurred."; this.namedRange2.AddComment("SelectionChange always occurs before BeforeDoubleClick."); this.namedRange2.Font.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.Black); }

Observação Porque faz duas vezes em uma célula em um intervalo do Excel com a seleção para mover para o intervalo, um SelectionChange evento ocorre antes de ocorrer o BeforeDoubleClick evento. Testar o aplicativo Agora você pode testar sua pasta de trabalho para verificar texto que descreve os eventos de um NamedRange controle que será inserido no outro intervalo nomeado quando os eventos são aumentados.

Para testar seu documento 7.

Pressione F5 para executar o projeto.

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.

Visual C# Consolidado

1091

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

Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Programação contra eventos dos XMLNode controles modo. Para obter mais informações, consulte Alterando o painel de ações de acordo com contexto do usuário Walkthrough:.

Passo-a-passo: Concedendo e removendo permissões para uma solução do Office Essa explicação passo a passo demonstra as noções básicas de segurança no Microsoft Visual Studio 2005 Tools for the Microsoft Office System. Durante este explicação passo a passo, você aprenderá como: •

Remova a configuração de segurança padrão.

•

Adicionar um novo conjunto de permissões.

•

Testar seu projeto. Pré-requisitos

Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

Microsoft Office Excel 2003. Criando o projeto

Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.

Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Security Test. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.

O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Security Test projeto para Solution Explorer. Adicionar código para trás a planilha Nesta etapa, você adicionará uma caixa de mensagem a um evento de inicialização da planilha.

Para adicionar uma caixa de mensagem a um evento de inicialização

Visual C# Consolidado

1092

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

15. No menu File, clique em Save All. 16. Na caixa Save Project de diálogo, digite C:\Walkthroughs na caixa Location. 17. Clique em Save. 18. Pressione F5 para executar o projeto. O Excel é iniciado e aparecerá a caixa de mensagem. 19. Fechar a caixa de mensagem. 20. Feche o Excel. 21. No designer do Visual Studio, localize e selecione na guia para My Security Test.xls. 22. 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 9.

No Painel de Controle, abra Administrative Tools.

10. Executar Microsoft .NET Framework 2.0 Configuration. 11. 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. 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. Será exibida uma caixa de diálogo perguntando se você tiver certeza que deseja excluir este grupo de códigos. 13. Clique em Yes.

Visual C# Consolidado

1093

14. 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. 15. Clique em OK. 16. 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 9.

No menu Project no Visual Studio, clique em My Security Test Properties.

10. Clique na Signing guia. 11. Selecione Sign the assembly. 12. No, o Choose a strong name key file list clique New. 13. Na caixa Create Strong Name Key de diálogo, digite SecurityTestKey na caixa Key file name. 14. Desmarque a Protect my key file with a password caixa de seleção. 15. Clique em OK. O arquivo SecurityTestKey.snk de chave aparece no Solution Explorer. 16. 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 10. Abra Microsoft .NET Framework 2.0 Configuration novamente. 11. Clique com o botão direito do mouse no VSTOProjects nó e clique New no menu de atalho 12. Digite o nome Security Test Strong Name para o novo grupo de códigos, e clique em Next. 13. Na lista Choose the condition type for this code group, clique Strong Name. 14. Clique em Import. 15. Procure C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\My para Visual Basic ou C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\debug\My no C#, e clique em Open.

Visual C# Consolidado

1094

16. Clique em Next. 17. Clique Next para aceitar o FullTrust conjunto de permissões e clique em Finish. 18. Fechar Microsoft .NET Framework 2.0 Configuration. Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se que seu código seja executado quando a pasta de trabalho é aberta.

Para testar sua pasta de trabalho 3.

Pressione F5 para executar o projeto.

4.

Confirme se a caixa de mensagem aparece.

Passo-a-passo: Ligando uma célula de planilha a um campo de banco de dados Essa explicação passo a passo demonstra noções básicas de vinculação um único campo de dados em um banco de dados do SQL Server a um intervalo nomeado no Microsoft Office Excel 2003. Ele inclui adicionar controles que permitem que você para percorrer todos os registros da tabela. Durante este explicação passo a passo, você aprenderá como: •

Criar uma fonte de dados para um projeto do Excel.

•

Adicionar controles a uma planilha.

•

Rolar pelos registros do banco de dados.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003.

•

Acesso a um servidor com o exemplo de SQL Server do Northwind.

•

Permissões para ler e gravar no banco de dados do SQL Server. Criando um novo projeto

Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.

Para criar um novo projeto

Visual C# Consolidado

1095

•

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

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,

10. Clique Add New Data Source Para iniciar o Data Source Configuration Wizard. 11. Selecione Database e, em seguida clique em Next. 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. 13. Após uma conexão foi selecionado ou criado, clique em Next. 14. Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next. 15. Expanda o Tables nó na janela Database objects. 16. Marque a caixa de seleção ao lado da Customers tabela. 17. Clique em Finish. O assistente adicionará a Customers tabela para a Data Sources janela. Ele também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. Adicionar controles a planilha Para essa explicação passo a passo, você precisa de dois intervalos nomeados e quatro botões na primeira planilha. Primeiro, adicione os dois intervalos nomeados a partir da Data Sources janela para que automaticamente eles são vinculados à fonte de dados. Em seguida, adicione os botões da Toolbox.

Para adicionar dois intervalos nomeados 8. 9.

Verifique se a My Simple Data Binding.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido. 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.

Visual C# Consolidado

1096

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

Na guia Common Controls Da adicionar um Button controle a célula A3 da planilha. o Toolbox, É nome Button1 este botão.

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. Inicializando as controles Definir o texto do botão e adicionar manipuladores de eventos durante o Startup evento.

Para inicializar os controles 4.

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

5.

Adicione o seguinte código para o Sheet1_Startup método para definir o texto para cada botão. C# this.button1.Text = "||";

6.

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

Visual C# Consolidado

1097

Agora, adicione código para manipular os Click eventos dos botões para que o usuário pode procurar pelos registros. Adicionar código para ativar rolagem através dos registros Adicione código ao manipulador Click de eventos de cada botão para percorrer os registros.

Para mover para o primeiro registro •

Adicionar um manipulador de eventos para o Click Evento do botão Button1, e adicione o código para mover para o primeiro registro a seguir: C# private void button1_Click(object sender, System.EventArgs e) { this.customersBindingSource.MoveFirst(); }

Para mover para o registro anterior •

Adicionar um manipulador de eventos para o Click Evento do botão Button2, e adicione o código a seguir para mover a posição de volta em um: C# private void button2_Click(object sender, System.EventArgs e) { this.customersBindingSource.MovePrevious(); }

Para mover para o próximo registro •

Adicionar um manipulador de eventos para o Click Evento do botão Button3, e adicione o código a seguir para avançar a posição em um: C# private void button3_Click(object sender, System.EventArgs e) { this.customersBindingSource.MoveNext(); }

Para mover para o último registro •

Adicionar um manipulador de eventos para o Click Evento do botão Button4, e adicione o código a seguir para mover para o último registro: C# private void button4_Click(object sender, System.EventArgs e) { this.customersBindingSource.MoveLast(); }

Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se que você pode navegar através dos registros no banco de dados.

Para testar sua pasta de trabalho 5.

Pressione F5 para executar o projeto.

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 >

Visual C# Consolidado

1098

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

Cache os dados para que ele possa ser usado off-line. Para obter mais informações, consulte Como dados de cache para uso off-line ou em um servidor:.

•

Vincular células para várias colunas em uma tabela, em vez da um campo. Para obter mais informações, consulte Walkthrough: vinculação células para várias colunas em uma tabela.

•

Usar um BindingNavigator controle para percorrer os registros. Para obter mais informações, consulte COMO: Navegar em dados com o controle BindingNavigator do Windows Forms.

Walkthrough: vinculação células para várias colunas em uma tabela Essa explicação passo a passo demonstra noções básicas de vinculação várias células em uma planilha do Microsoft Office Excel 2003 a campos no banco de dados Northwind do SQL Server. Durante este explicação passo a passo, você aprenderá como: •

Adicionar controles a uma planilha.

•

Salva qualquer alteração de dados de volta para o banco de dados.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003.

•

Acesso a um servidor com o exemplo de SQL Server do Northwind.

•

Permissões para ler e gravar no banco de dados do SQL Server. Criando um novo projeto

Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.

Para criar um novo projeto Visual C# Consolidado

1099

•

Criar um projeto de pasta de trabalho do Excel com o nome My Complex Data Binding, usando o Visual Basic ou C#. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Complex Data Binding projeto para Solution Explorer. Criando o DataSet

Use a Data Sources janela para adicionar um DataSet digitado ao seu projeto.

Para criar o DataSet 9.

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,

10. Clique Add New Data Source Para iniciar o Data Source Configuration Wizard. 11. Selecione Database e, em seguida clique em Next. 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. 13. Após uma conexão foi selecionado ou criado, clique em Next. 14. Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next. 15. Expanda o Tables nó na janela Database objects. 16. Marque a caixa de seleção ao lado da Employees tabela. 17. Clique em Finish. O assistente adicionará a Employees tabela para a Data Sources janela. Ele também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. Adicionar controles a planilha Para essa explicação passo a passo, você precisa um ListObject controle e um Button controle na primeira planilha. Primeiro, adicione o ListObject controle a partir da Data Sources janela para que ela está vinculada automaticamente à fonte de dados. Em seguida, adicione o Button controle da Toolbox.

Para adicionar um ListObject 5.

Verifique se a My Complex Data Binding.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.

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

Visual C# Consolidado

1100

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

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

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 Sheet1_Startup método.

C# this.button1.Click += new EventHandler(button1_Click);

Agora, adicione código para manipular o Click Evento do botão. Salvar alterações no banco de dados As alterações tenham sido feitas o dados existe somente no dataset local até que eles são salvos explicitamente volta para o banco de dados.

Para salvar as alterações feitas o banco de dados •

Adicionar um manipulador de eventos para o Click evento do b utton, e adicione o código a seguir para confirmar todas as alterações que foram feitas no dataset volta para o banco de dados: C# private void button1_Click(object sender, EventArgs e) { try { this.employeesTableAdapter.Update(this.northwindDataSet.Employees); } catch (System.Data.DataException ex) { MessageBox.Show(ex.Message); } }

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 Visual C# Consolidado

1101

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

Selecionar linha 16, que deve conter a nova linha que você adicionou, clicando no número 16 no lado esquerdo da planilha. No menu Edit, clique em Delete.

Para classificar as linhas na lista 4.

Selecione uma célula dentro da 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.

Visual C# Consolidado

1102

6.

Clique em Sort Ascending. As linhas são classificadas em ordem alfabética por sobrenome.

Para filtrar informações 6.

Selecione uma célula dentro da lista.

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

Cache os dados para que ele possa ser usado off-line. Para obter mais informações, consulte Como dados de cache para uso off-line ou em um servidor:.

•

Implantar a solução. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Criar uma relação mestre / detalhes entre um campo e uma tabela. Para obter mais informações, consulte Criando uma relação mestre / detalhes usando um DataSet em cache Walkthrough:.

Criando uma relação mestre / detalhes usando um DataSet em cache Walkthrough: Essa explicação passo a passo demonstra criar uma relação mestre / detalhes em uma planilha, e cache os dados para que a solução pode ser usada off-line. Durante este explicação passo a passo, você aprenderá como: •

Adicionar controles a uma planilha.

•

Configurar um DataSet para ser armazenados em uma planilha.

•

Adicione código para Habilitar rolagem pelos registros.

•

Testar seu projeto. Observação

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

Visual C# Consolidado

1103

•

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003.

•

Acesso ao exemplo de SQL Server do Northwind. O banco de dados pode ser no seu computador de desenvolvimento ou em um servidor. Permissões para ler e gravar no banco de dados do SQL Server.

•

Criando um novo projeto Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel. Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Master-Detail, usando o Visual Basic ou C#. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.

O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My MasterDetail projeto para Solution Explorer. Criando o DataSet Use a Data Sources janela para adicionar um DataSet digitado ao seu projeto.

Para criar o DataSet 9.

Se a Data Sources janela não estiver visível, clique Show Data Sources no Data menu.

10. Clique Add New Data Source Para iniciar o Data Source Configuration Wizard. 11. Selecione Database e, em seguida clique em Next. 12. Selecionar uma conexão de dados ao banco de dados de exemplo Northwind do SQL Server ou adicionar uma nova conexão usando o New Connection botão. 13. Após selecionar ou criar uma conexão, clique em Next. 14. Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next. 15. Expanda o Tables nó na janela Database objects. 16. Selecione a Orders tabela e a Order Details tabela. 17. Clique em Finish. O assistente adicionará as duas tabelas para a Data Sources janela. Ele também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. Adicionar controles a planilha Nesta etapa, você adicionará um intervalo nomeado, um objeto de lista, e dois botões à primeira planilha. Primeiro, adicionar o intervalo nomeado e o objeto lista a partir da Data Sources janela para que automaticamente eles são vinculados à fonte de dados. Em seguida, adicione os botões da Toolbox.

Para adicionar um intervalo nomeado e um objeto de lista 8. 9.

Verifique se a My Master-Detail.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido. Abra a Data Sources janela e expanda o Orders nó.

Visual C# Consolidado

1104

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 instância são adicionados ao projeto. um BindingSource O controle é acoplado que por sua vez está vinculado a DataSet instância. o BindingSource, 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 3.

Na guia Common Controls Da adicionar um Button controle a célula A3 da planilha. o Toolbox, É nome Button1 este botão.

4.

Adicionar um outro Button controle a célula B3 da planilha. É nome Button2 este botão.

Em seguida, marcar DataSet para ser armazenado em cache no documento. Cache o DataSet Marcar DataSet para ser armazenado em cache no documento, tornar DataSet públicos e definindo a CacheInDocument propriedade. Armazenar em cache DataSet 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. Inicializando as controles Definir o texto do botão e adicionar manipuladores de eventos durante o Startup evento.

Ao inicializar os dados e os controles 4.

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

5.

Adicione o seguinte código para o Sheet1_Startup método para definir o texto para os botões. C#

Visual C# Consolidado

1105

this.button1.Text = "";

6.

Para C# só, adicionar manipuladores de eventos para o botão clique eventos para o Sheet1_Startup método.

C# this.button1.Click += new EventHandler(button1_Click); this.button2.Click += new EventHandler(button2_Click);

Adicionar código para ativar rolagem através dos registros Adicione código ao manipulador Click de eventos de cada botão para percorrer os registros. Para percorrer os registros 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 Agora você pode testar sua pasta de trabalho para certificar-se de que os dados aparecem como esperado, e que você pode usar a solução off-line. Para testar o cache de dados 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 banco de dados for no seu computador de desenvolvimento. 14. Abra o Excel, e abra My Master-Detail.xls a partir do diretório \bin (\My Detail\bin mestreno 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 banco de dados for no seu computador de desenvolvimento. Próximas etapas Essa explicação passo a passo mostra as noções básicas de criar uma relação mestre / detalhes de dados em uma planilha e cache um DataSet. Aqui estão algumas tarefas que podem vie em seguida:

Visual C# Consolidado

1106

•

Implantar a solução. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Recuperar dados de cache para outro projeto. Para obter mais informações, consulte Como recuperar dados de uma pasta de trabalho em um servidor em cache:.

Walkthrough: atualizando um gráfico em uma planilha usando botões de opção Essa explicação passo a passo mostra os fundamentos básicos do alterando estilos do gráfico usando botões de opção em um planilha do Microsoft Office Excel 2003. Para ver o resultado como uma amostra completa, consulte Exemplo do Excel de controles. Durante este explicação passo a passo, você aprenderá como: •

Adicionar um controle de usuário para uma planilha.

•

Alterar o estilo do gráfico quando uma opção está selecionada.

•

Testar seu projeto. Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003. Adicionar um gráfico a uma planilha

Você pode criar um projeto de pasta de trabalho do Excel usando uma pasta de trabalho existente. Nessa explicação passo a passo, irá adicionar um gráfico à pasta de trabalho e Usar pasta de trabalho no Excel uma nova solução. A fonte de dados nessa explicação passo a passo é uma planilha chamada Data for Chart. Para adicionar os dados 5.

Abra o Excel 2003. Abre uma nova pasta de trabalho.

6. 7. 8.

Clique com o botão direito do mouse na Sheet3 guia e, em seguida clique Rename no menu de atalho. Renomear a planilha para Data for Chart. 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

Visual C# Consolidado

Q3

Q4

1107

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 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. 19. Clique em Finish. 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. Criando um novo projeto Nesta etapa, você irá criar um projeto usando Visual Studio Tools for Office pasta de trabalho do Excel. Para criar um novo projeto 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 Como criar Ferramentas do Visual Studio para projetos do Office:.

5.

Clique no Browse botão e vá para a pasta de trabalho que você criou anteriormente nessa explicação passo a passo.

6.

Clique em OK. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel Chart projeto para Solution Explorer. Definindo Propriedades do gráfico

Quando você criar um novo projeto pasta de trabalho do Excel usando uma pasta de trabalho existente, controles host automaticamente são criados para intervalos nomeados, objetos lista, e gráficos que existem dentro da pasta de trabalho. Você pode alterar o nome do controle Chart usando a Properties janela

Visual C# Consolidado

1108

Para alterar o nome do controle gráfico •

Selecione o Chart controle no designer e alterar as seguintes propriedades na janela Properties: Propriedade

Value (Valor)

Name

dataChart

HasLegend

False

Adicionar um controle de usuário ao projeto Para adicionar um controle de usuário 4.

Selecione o My Excel Chart projeto no Solution Explorer.

5.

No menu Project, clique em Add New Item.

6.

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

Se o controle de usuário estiver não visível no designer, clique duas vezes em ChartOptions no Solution Explorer.

7.

Na guia Common Controls Da arraste um Radio Button controle para o controle de usuário, e alterar as seguintes propriedades: o Toolbox,

8.

9.

Propriedade

Value (Valor)

Name

columnChart

Text

Gráfico de coluna

Adicionar um botão de opção segundo para o controle de usuário, e alterar as propriedades a seguir: Propriedade

Value (Valor)

Name

barChart

Text

Gráfico de barras

Adicionar um botão de opção terceiro para o controle de usuário, e alterar as propriedades a seguir: Propriedade

Value (Valor)

Name

lineChart

Text

Gráfico de linha

Visual C# Consolidado

1109

10. Adicionar um botão de opção quarto para o controle de usuário, e alterar as propriedades a seguir: Propriedade

Value (Valor)

Name

areaBlockChart

Text

Gráfico bloquear de área

Em seguida, escreva o código para atualizar o gráfico quando um botão de opção é clicado. Alterar o gráfico estilo quando um botão de opção é selecionada Nesta seção, você será criar um evento público sobre o controle de usuário, adicionar uma propriedade para definir o tipo de seleção, e criar um manipulador de eventos para o CheckedChanged evento de cada um dos botões de opção. Para criar um evento e propriedade em um controle de usuário 3. 4.

No Solution Explorer, clique com o botão direito do mouse no controle de usuário e selecione View Code. 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 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# 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); } } }

7.

Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão barChart de opção. C# private void barChart_CheckedChanged(object sender, EventArgs e) { if (((RadioButton)sender).Checked) { this.selectedType = Microsoft.Office.Interop.Excel.XlChartType.xlBarClustered; if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } } }

8.

Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão columnChart de opção. C#

Visual C# Consolidado

1110

private void columnChart_CheckedChanged(object sender, EventArgs e) { if (((RadioButton)sender).Checked) { this.selectedType = Microsoft.Office.Interop.Excel.XlChartType.xlColumnClustered; if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } } }

9.

Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão lineChart de opção. C# private void lineChart_CheckedChanged(object sender, EventArgs e) { if (((RadioButton)sender).Checked) { this.selectedType = Microsoft.Office.Interop.Excel.XlChartType.xlLineMarkers; if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } } }

10. Em C#, você deve adicionar manipuladores de eventos para os botões de opção. Adicione o código para o ChartOptions Construtor, sob a chamada para InitializeComponent, conforme mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C# public ChartOptions() { InitializeComponent(); areaBlockChart.CheckedChanged += new EventHandler(areaBlockChart_CheckedChanged); barChart.CheckedChanged += new EventHandler(barChart_CheckedChanged); columnChart.CheckedChanged += new EventHandler(columnChart_CheckedChanged); lineChart.CheckedChanged += new EventHandler(lineChart_CheckedChanged); }

Adicionar o controle de usuário a planilha Quando você cria a solução, o novo controle de usuário é automaticamente adicionado à Toolbox. Você pode, então, arrastar o controle da Toolbox. para seu Worksheet Para adicionar o controle do usuário sua planilha 4.

No menu Build, clique em Build Solution. O ChartOptions controle de usuário é adicionado à Toolbox.

5. 6.

Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs. e selecione View Designer 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 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()); } }

Visual C# Consolidado

1111

4.

Em C#, adicione um manipulador de eventos para o controle de usuário para o Startup evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C# this.ChartOptions1.SelectionChanged += new EventHandler(ChartOptions1_SelectionChanged);

Testar o aplicativo Agora você pode testar sua pasta de trabalho para certificar-se que o gráfico tiver estilo corretamente quando você seleciona um botão de opção. Para testar sua pasta de trabalho 4.

Pressione F5 para executar o projeto.

5.

Selecione vários botões de opção.

6.

Confirme que o estilo do gráfico altera para correspondem à seleção. Próximas etapas

Essa explicação passo a passo mostra noções básicas sobre como usar botões de opção e estilos do gráfico nas planilhas do Excel 2003. Aqui estão algumas tarefas que podem vie em seguida: •

Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Usando um botão para preencher uma caixa de texto. Para obter mais informações, consulte Exibindo texto em uma caixa de texto em uma planilha usando um botão Walkthrough:.

•

Alterar a formatação em uma planilha usando caixas de seleção. Para obter mais informações, consulte Alterando planilha formatação usando controles CheckBox Walkthrough:.

Vinculação de Dados para controles em um painel Ações do Excel Walkthrough: Essa explicação passo a passo demonstra vinculação de dados a controles em um painel Ações no Microsoft Office Excel 2003. Os controles demonstram uma Relação mestre / detalhes entre tabelas em um banco de dados do SQL Server. Durante este explicação passo a passo, você aprenderá como: •

Adicionar controles a uma planilha.

•

Criar um controle painel Ações.

•

Adicionar controles Windows Forms ligados a dados a um controle painel Ações.

•

Mostrar painel de ações quando abre o aplicativo.

•

Testar seu projeto. Observação

Visual C# Consolidado

1112

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •

Microsoft Visual Studio 2005 Tools for the Microsoft Office System

•

Microsoft Office Excel 2003.

•

Acesso a um servidor com o exemplo de SQL Server do Northwind.

•

Permissões para ler e gravar no banco de dados do SQL Server. Criando o projeto

A primeira etapa é para criar um projeto de pasta de trabalho do Excel. Para criar um novo projeto •

Criar um projeto de pasta de trabalho do Excel com o nome My Excel Actions Pane. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel Actions Pane projeto para Solution Explorer. Adicionar uma nova fonte de dados ao projeto

Para adicionar uma nova fonte de dados para o projeto 10. Se a Data Sources janela não estiver visível, clique Show Data Sources no Data menu. Observação Se Show Data Sources clique dentro na planilha do Excel e depois verificar novamente. não estiver disponível, 11. Clique Add New Data Source Para iniciar o Data Source Configuration Wizard. 12. Selecione Database e, em seguida clique em Next. 13. 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. 14. Clique em Next. 15. Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next. 16. Expanda o Tables nó na janela Database objects. 17. Marque a caixa de seleção ao lado da Suppliers tabela. 18. Expandir a Products tabela e selecione ProductName, SupplierID, QuantityPerUnit. e UnitPrice 19. Clique em Finish. O assistente adiciona a Suppliers tabela e Products Tabela à janela Data Sources. Ele também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer.

Visual C# Consolidado

1113

Adicionar controles a planilha Em seguida, adicione um NamedRange controle e um ListObject controle à primeira planilha. Para adicionar um NamedRange e um controle ListObject 8. 9.

Verifique se a My Excel Actions Pane.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido. 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 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. 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 4.

Selecione o My Excel Actions Pane projeto no Solution Explorer.

5.

No menu Project, selecione Add New Item.

6.

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

6.

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

Visual C# Consolidado

1114

Para definir propriedades de vinculação de dados do controle 4. 5.

Clique com o botão direito do mouse no controle painel Ações e selecione View Code a partir do menu de atalho 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 manipuladores de eventos em Ferramentas do Visual Studio do Office:. C# public ActionsControl() { InitializeComponent(); this.Load += new EventHandler(ActionsControl_Load); }

Mostrando o Painel de Ações Você nesta seção, vai escrever código para mostrar o painel Ações. O painel Actions ficará visível depois controles são adicionados a ele. Para mostrar o painel Ações 3.

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

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# private void ThisWorkbook_Startup(object sender, System.EventArgs e) { this.ActionsPane.Controls.Add(actions); }

Testar o aplicativo Agora você pode testar seu documento para verificar o painel Ações que é aberto quando o documento for aberto. Você testará para a relação mestre / detalhes entre os controles no painel de ações e os controles da planilha. Para testar seu documento 5.

Pressione F5 para executar o projeto.

6.

Confirme se o painel Actions está visível.

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

Visual C# Consolidado

1115

Essa explicação passo a passo mostra as noções básicas de vinculação de dados a controles em um painel Ações no Excel. Aqui estão algumas tarefas que podem vie em seguida: •

Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:.

•

Ligação de dados a controles no Word. Para obter mais informações, consulte Vinculação de Dados para controles em um painel Ações do Word Walkthrough:.

•

Mostrar e ocultar controles no painel de ações. Para obter mais informações, consulte Alterando o painel de ações de acordo com contexto do usuário Walkthrough:

Implantando um Word ou Solution do Excel usando um manifesto Deployment Walkthrough: Essa explicação passo a passo demonstra como implantar uma solução o Microsoft Office Excel ou Microsoft Office Word em um compartilhamento de rede em um servidor. Será posicionado no final do explicação passo a passo, o possível para executar a solução no servidor do seu computador de desenvolvimento. Em um ambiente de produção, uma Microsoft Visual Studio 2005 Tools for the Microsoft Office System solução geralmente é publicada primeiro a um servidor de teste, e depois ele é reimplantado em um servidor de produção depois que o departamento de TI aprovar-. Você nessa explicação passo a passo, será emular esse processo, publicando uma solução em um local temporário no seu computador de desenvolvimento, e então redeploying a solução do local de publicação para um servidor. Para obter mais informações sobre as opções para implantar a solução, consulte Modelos de implantação. Durante este explicação passo a passo, você aprenderá como: •

Do Publish Wizard uso para publicar sua solução em um local no seu computador de desenvolvimento.

•

Manualmente relançamento a solução do seu computador local para um compartilhamento de rede em um servidor.

•

Modificar o manifesto do aplicativo que está incorporado no documento para apontar para o novo local manifesto de implantação programaticamente.

•

Editar a manifesto de implantação para apontar para a nova localização do manifesto do aplicativo externos.

•

Editar o manifesto do aplicativo externo para apontar para o novo local do conjunto e a manifesto de implantação. Pré-requisitos

Para concluir esta explicação passo a passo, será necessário: •

Visual Studio Tools for Office

•

O Word Microsoft Office 2003 ou Microsoft Office Excel 2003. Observação 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

Visual C# Consolidado

1116

projeto do Word com o nome do seu projeto do Excel em todos os códigos e exemplos XML. •

Acesso a um servidor de rede para implantação. Essa explicação passo a passo pressupõe que você são redeploying sua solução para o \\DeployServer\ShareFolder compartilhamento de rede.

•

Privilégios de administrador no computador de desenvolvimento, para que você possa definir a diretiva de segurança para um local de rede. Criando o projeto

Nesta etapa, você irá criar um projeto Documento do Word. Para criar um novo projeto •

Criar um projeto Documento do Word com o nome WordDeployment. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.

Abre o novo documento do Word no designer e adiciona o WordDeployment projeto para Solution Explorer o Visual Studio. Adicionar código para trás o documento Nesta etapa, você adicionará uma caixa de mensagem ao manipulador Startup de eventos do documento. Isso permitirá que você para verificar se a solução está funcionando quando você abre o documento rapidamente. Para adicionar uma caixa de mensagem a um evento de inicialização 6.

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

7.

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

8.

Pressione F5 para executar o projeto. Inicia o Word e a caixa de mensagem aparece.

9.

Fechar a caixa de mensagem.

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

Clique com o botão direito do mouse o nó de projeto no Solution Explorer.

7.

Clique Publish no menu de atalho. O Publish Wizard aparece.

Visual C# Consolidado

1117

8.

Na caixa Specify the location to publish this application, digite C:\TestDeploy.

9.

Clique em Finish. O documento de Solução e manifesto de implantação são copiados para C:\TestDeploy. O conjunto de solução, atualizado manifesto do aplicativo, e cópias do documento de Solução e manifesto de implantação são copiadas para C:\TestDeploy\WordDeployment_1.0.0.0. Para obter mais informações, consulte Implantando o Word e Excel Solutions.

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

Criar um novo projeto Console Application.

7.

Do Microsoft.VisualStudio.Tools.Applications.Runtime Adicionar referências para e System.Windows.Forms montagens para este projeto.

8.

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;

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 propriedade, e salva e fecha o ServerDocument.. o ServerDocument C#

Visual C# Consolidado

1118

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

10. Pressione F5 para executar o projeto. Uma janela do console aparece rapidamente enquanto o manifesto do aplicativo incorporado está sendo atualizado, e fecha a janela do console. Atualizando o manifesto de implantação Agora que você atualizou o manifesto do aplicativo incorporado no documento Visual Studio Tools for Office de solução, você deve atualizar a manifesto de implantação para apontar para a nova localização do manifesto do aplicativo externos. Para atualizar a manifesto de implantação 4.

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.

5.

Defina o codebase atributo do elemento 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: