10 ejercicios comunes sobre visual studio c#Descripción completa
Learn the basics of Visual C# programming. Easy to learn and read tutorial for beginners.
Descripción completa
Descripción: Guia prático de C# para iniciantes, muito bom...
Guia prático de C# para iniciantes, muito bom...
Apostila de c++ usada na universidade estácio de sá
Full description
Descrição: Apostila de Linguagem C para pic
Descripción: Apostila de Linguagem C para pic
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
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#
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#
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#
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#
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#
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#
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#
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:
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#
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#
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#
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#
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#
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 Element (Visual Studio Tools for Office Reference).O atributo para essa explicação passo a passo deve aspecto como este:
3.
Salve e feche o arquivo manifesto de implantação. Atualizando o manifesto de aplicativos externos
Além disso, para atualizar a manifesto de implantação, você também deve editar o manifesto do aplicativo externo para apontar para os locais implantação final do conjunto de solução e a manifesto de implantação. Sempre que você publicar uma Visual Studio Tools for Office solução, um novo manifesto do aplicativo externo é gerado que aponta para a versão atual do conjunto de solução.
Para atualizar o manifesto do aplicativo externo 1.
Abra o manifesto do aplicativo em um editor de texto, como o Bloco de notas. O manifesto do aplicativo é denominado WordDeployment.dll.manifest, e está localizado na pasta C:\TestDeploy\WordDeployment_1.0.0.0 de publicação.
2.
Localize o elemento que está o filho do elemento , e defina o codebase atributo como o caminho completo da montagem de solução atual. Para obter mais informações, consulte Element (Visual Studio Tools for Office Reference).O atributo para essa explicação passo a passo deve aspecto como este:
3.
Localize o elemento que está o filho do elemento , e defina o codebase atributo para o caminho completo do manifesto de implantação. Para obter mais informações, consulte Element (Visual Studio Tools for Office Reference).O atributo para essa explicação passo a passo deve aspecto como este:
4.
Salve e feche o arquivo manifesto do aplicativo. Copiando os arquivos da solução para o servidor
Agora que você tiver editado os manifestos, você está pronto para copiar os arquivos de solução para o servidor.
Para copiar os arquivos de solução para o servidor 1.
Crie uma WordDeployment_1.0.0.0 pasta sob a \\DeployServer\ShareFolder compartilhamento de arquivos de rede.
Visual C# Consolidado
106
2.
Copiar o documento de Solução e a manifesto de implantação para \\DeployServer\ShareFolder.
3.
Copiar o conjunto de solução e o manifesto do aplicativo para \\DeployServer\ShareFolder\WordDeployment_1.0.0.0. Conceder confiança total para a pasta de rede
Para execute sua Visual Studio Tools for Office solução a partir da pasta de rede, você deve conceder confiança total para a pasta de rede na sua diretiva de segurança no computador de desenvolvimento. Você pode modificar a diretiva de segurança de um prompt de comando usando a ferramenta Diretiva de Segurança para Acesso ao Código (Caspol.exe). Para conceder confiança para um local de rede, você deve ter privilégios de administrador e você deverá alterar a diretiva de segurança no nível do computador. Observação Este procedimento é destinado a fim de executar essa explicação passo a passo. Não use este procedimento para conceder confiança a conjuntos ou diretórios se não tiver certeza que sejam segura e protegida. Para obter mais informações sobre concessão e remover permissões, consulte HOW TO: conceder permissões para pastas e montagens e Como remover permissões de pastas e montagens:.
Para conceder confiança total para a pasta de rede Digite o seguinte comando no prompt de comando Studio visual:
•
caspol -m -ag LocalIntranet_Zone -url \\DeployServer\ShareFolder\* FullTrust -n "Remote Deployment" -d "Deployment Walkthrough" Testando a solução Agora você pode testar sua solução para certificar-se que seu código seja executado quando você abre o documento a partir do computador de desenvolvimento.
Para testar a implantação 1. 2.
No computador de desenvolvimento, abra o WordDeployment.doc arquivo no \\DeployServer\ShareFolder\. Confirme se a caixa de mensagem aparece. Próximas etapas
Você também pode implantar a solução usando um arquivo do Microsoft Windows Installer (.msi). Para obter mais informações, consulte Implantando um Word ou Solution do Excel usando um arquivo do Windows Installer Walkthrough:.
Implantando um Word ou Solution do Excel usando um arquivo do Windows Installer Walkthrough: Essa explicação passo a passo demonstra como criar um arquivo do Microsoft Windows Installer (.msi) que pode ser usado para implantar uma solução Microsoft Office Excel 2003 ou Microsoft Office Word 2003. Durante este explicação passo a passo, você aprenderá como: •
Criar um projeto de instalação que você pode usar para criar um arquivo do Windows Installer.
•
Modifique o projeto de instalação para que o arquivo Windows Installer instala sua Microsoft Visual Studio 2005 Tools for the Microsoft Office System solução.
Visual C# Consolidado
107
•
Adicionar uma etapa para o projeto de instalação para que Arquivo do Windows Installer edita o manifesto do aplicativo incorporados no Visual Studio Tools for Office documento de solução.
Essa explicação passo a passo pressupõe que o computador de destino já tiver os pré-requisitos instalados para executar Visual Studio Tools for Office soluções. Você cria o arquivo Windows Installer não o verificar ou instalar esses pré-requisitos. Para obter mais informações sobre os prérequisitos para executar Visual Studio Tools for Office soluções, consulte Como se preparar computadores de usuário final para executar soluções do Office:. Observação Conjuntos em Visual Studio Tools for Office Soluções devem ser concede confiança total na diretiva de segurança do usuário final antes da solução seja executado. O arquivo Windows Installer você criar nessa explicação passo a passo não Não implantar a diretiva de segurança necessário para executar a solução. Para obter mais informações sobre segurança em Visual Studio Tools for Office soluções, consulte Requisitos de segurança para executar soluções do Office e Práticas recomendadas para segurança no Office Solutions. Para obter informações sobre como configurar a diretiva de segurança por usuário final computadores, consulte Implantação de diretiva de segurança. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •
Visual Studio Tools for Office
•
O Word Microsoft Office 2003 ou Microsoft Office Excel 2003. Observação Essa explicação passo a passo inclui etapas para criar uma solução simples que você pode usar em explicação passo a passo o Excel. Se você deseja executar o explicação passo a passo com uma solução Word ou Excel existente, começarão o explicação passo a passo no título criando o Project a instalação, " " e certifique-se substituir o nome ExcelDeployment do projeto com o nome do seu projeto em todos os exemplos de código e instruções. Criando o projeto
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.
Para criar um novo projeto •
Criar um projeto de pasta de trabalho do Excel com o nome ExcelDeployment. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o ExcelDeployment projeto para Solution Explorer. Adicionar código para trás a pasta de trabalho Nesta etapa, você adicionará uma caixa de mensagem ao manipulador Startup de eventos da pasta de trabalho. Isso permite que você para verificar se a solução está funcionando quando você abre o documento rapidamente.
Para adicionar uma caixa de mensagem a um evento de inicialização 1.
Clique com o botão direito do mouse ThisWorkbook.vb no Solution Explorer, ou ThisWorkbook.cs,. e, em seguida clique View Code no menu de atalho
2.
Adicione o seguinte código ao manipulador Startup de eventos dentro a ThisWorkbook classe para mostrar uma caixa de mensagem durante a inicialização. C#
Pressione F5 para executar o projeto. O Excel é iniciado e aparecerá a caixa de mensagem.
4.
Fechar a caixa de mensagem.
5.
Saia do Excel.
Em seguida, você adicionará um projeto de instalação para sua solução. Criar um projeto de instalação Nesta etapa, você irá criar um projeto de instalação que você pode compilar para criar um arquivo do Windows Installer para sua solução. Para obter mais informações, consulte Configurar projetos.
Para criar um projeto de instalação para a solução 1.
Clique com o botão direito do mouse no nó na Solution Explorer solução.
2.
Aponte para Add no menu de atalho, e clique em New Project. A Add New Project caixa de diálogo será exibida.
3.
No painel Project types, expanda Other Project types e selecione Setup and Deployment.
4.
No painel Templates, selecione Setup project.
5.
Nome do projeto ExcelSetup.
6.
Clique em OK. O projeto instalação aparece no Solution Explorer. Por padrão, o arquivo que você irá criar usando este projeto instalação Windows Installer inclui uma caixa de diálogo que permite ao usuário final que especifique o local de instalação da solução. Para obter mais informações, consulte Caixa de diálogo interface do usuário da pasta de instalação. Adicionar o pasta de trabalho e assembly da solução para o Project da instalação
Nesta etapa, você adicionará a saída do projeto ExcelDeployment principal para o projeto de instalação. A saída do projeto ExcelDeployment principal consiste de pasta de trabalho e o conjunto de solução.
Para adicionar o documento e conjunto ao projeto de instalação 1.
Clique com o botão direito do mouse no ExcelSetup project nó em Solution Explorer.
2.
Selecione View no menu de atalho, e depois clique em File System.
3.
Clique com o botão direito do mouse Application Folder no painel esquerdo.
4.
Aponte para Add no menu de atalho, e clique em Project Output.
5.
Selecione ExcelDeployment na caixa Project.
6.
Selecione Primary output na lista de tipos de saída.
7.
Clique em OK. A saída do projeto e dependências aparecem no painel direito.
8.
No Solution Explorer, expanda Detected Dependencies sob o ExcelSetup nó de projeto.
9.
Clique com botão direito mouse cada dependência, exceto para Microsoft .NET Framework, e clique Exclude no menu de atalho.
Visual C# Consolidado
109
Criar um projeto de ação personalizada Nesta etapa, você irá criar um projeto que contém ações personalizadas para o projeto de instalação. Ações personalizadas são um recurso do Windows Installer que permitem a você para executar código no final de uma instalação para executar ações que não podem ser executadas durante a instalação. Para obter mais informações, consulte Ações Personalizadas.
Para criar um projeto ação personalizada 1.
Clique com o botão direito do mouse no nó na Solution Explorer solução.
2.
Aponte para Add no menu de atalho, e clique em New Project. A Add New Project caixa de diálogo será exibida.
3.
No painel Project types, expanda o nó para a linguagem de programação, e selecione Windows.
4.
No painel Templates, selecione Class Library.
5.
Nome do projeto ExcelCustomAction.
6.
Clique em OK. O novo projeto aparece na Solution Explorer.
7.
No Solution Explorer, clique com o botão direito do mouse Class1.vb ou Class1.cs sob o ExcelCustomAction projeto e, em seguida, clique em Delete. Este arquivo é desnecessário para essa explicação passo a passo. Criar uma ação personalizada que salvas o manifesto de aplicativo
Quando você executava seu projeto anteriormente nessa explicação passo a passo pelo pressionamento F5, a processo de criação editado o manifesto do aplicativo incorporado na pasta de trabalho para aponte para o caminho relativo do conjunto. Se a pasta de trabalho e o conjunto permanecer na mesma pasta após a instalação, então você não precisam modificar o manifesto do aplicativo incorporado, e você pode ignorar esta seção. No entanto, se você quiser que o usuário possa mover a pasta de trabalho para uma pasta diferente após a instalação, você deve editar o manifesto do aplicativo para apontar para o caminho completo da montagem. Você deve atualizar o manifesto do aplicativo que está incorporado no Visual Studio Tools for Office documento de Solução ao executar uma ação personalizada após a instalação, porque o local do conjunto de solução é desconhecido até que o usuário especifica o local durante a instalação. Editar o manifesto do aplicativo incorporado, usando a ServerDocument classe. Para usar a ServerDocument classe no projeto de instalação, adicione código para uma Installer classe dentro do projeto ação personalizada.
Para criar uma ação personalizada que edita o manifesto do aplicativo 1.
Clique com o ExcelCustomAction projeto no Solution Explorer.
2.
Aponte para Add no menu de atalho, e clique em New Item. A Add New Item caixa de diálogo será exibida.
3.
Selecionar Installer Class, e nome da classe ManifestEditor.
4.
Adicione uma referência ao conjunto Microsoft.VisualStudio.Tools.Applications.Runtime para o ExcelCustomAction projeto.
5.
Do ManifestEditor.cs clique com o botão direito do mouse no Solution Explorer, ou ManifestEditor.vb arquivo e clique em View Code.
6.
Adicione a instrução seguinte Imports ou using para o topo do arquivo de código. C#
using Microsoft.VisualStudio.Tools.Applications.Runtime;
Visual C# Consolidado
110
7.
Copie o código a seguir para a ManifestEditor classe. Esse código substitui o Install método, que é usado para executar ações Instalação personalizada. O código define o local de instalação especificado pelo usuário para a AssemblyPath propriedade. O caminho de instalação especificado pelo usuário e os nomes do documento e conjunto são obtidas a partir da Parameters propriedade. C#
// Override the Install method to update the customization location // in the application manifest. public override void Install(System.Collections.IDictionary stateSaver) { UpdateApplicationManifest(); base.Install(stateSaver); } // Update the application manifest according to the the install location. private void UpdateApplicationManifest() { // Get the parameters passed to the task. string targetDir = this.Context.Parameters["targetdir"]; string documentName = this.Context.Parameters["documentname"]; string assemblyName = this.Context.Parameters["assemblyname"]; // Get the application manifest from the document. string documentPath = System.IO.Path.Combine(targetDir, documentName); ServerDocument serverDocument1 = new ServerDocument(documentPath, System.IO.FileAccess.ReadWrite); try { AppManifest appManifest1 = serverDocument1.AppManifest; string assemblyPath = System.IO.Path.Combine(targetDir, assemblyName); appManifest1.Dependency.AssemblyPath = assemblyPath; serverDocument1.Save(); } finally { if (serverDocument1 != null) { serverDocument1.Close(); } } } 8.
Clique com o ExcelCustomAction projeto no Solution Explorer, e, em seguida clique em Build. Adicionando a ação personalizada ao projeto de instalação
Nesta etapa, você adicionará a saída do projeto ExcelCustomAction principal para o projeto de instalação. Isso permite que o arquivo Windows Installer para executar a ação personalizada que edita o manifesto do aplicativo.
Para adicionar a saída primária do projeto ação personalizada ao projeto de instalação 1. 2. 3.
Clique com o botão direito do mouse no ExcelSetup project nó em Solution Explorer. Aponte para View no menu de atalho, e clique em Custom Actions. O Custom Actions Editor, clique com botão direito no nó e Install Clique em Add Custom Action.
4.
Na caixa Look In Selecionar Application Folder, e clique em Add Output
5.
Selecione ExcelCustomAction na caixa Project.
6.
Selecione Primary output na lista de tipos de saída, e depois clique em OK.
7.
Verifique que Primary output from ExcelCustomAction (Active) foi adicionado à lista de saídas primária para o projeto de instalação e clique em OK
Visual C# Consolidado
111
8. 9.
Em expandir Install. o Custom Actions Editor, Clique com o botão direito do mouse Primary output from ExcelCustomAction (Active) e, em seguida clique em Properties Window.
10. Na janela Properties, defina a CustomActionData propriedade para a seguinte seqüência: /targetdir="[TARGETDIR]/" /documentname="ExcelDeployment.xls" /assemblyname="ExcelDeployment.dll" Para obter informações sobre a CustomActionData propriedade, consulte Propriedade CustomActionData. 11. Clique com o botão direito do mouse e, em seguida clique em Build. Em Solution Explorer, o ExcelSetup project Teste a instalação Agora você pode testar a solução para garantir que sua solução é instalada quando você executar o arquivo do Windows Installer no seu computador de desenvolvimento.
Para testar a instalação 1.
Clique com o botão direito do mouse e, em seguida clique em Run. Em Solution Explorer, o ExcelSetup project
2.
Siga as instruções no Assistente de Instalação, e especificar uma pasta de instalação no seu computador de desenvolvimento.
3.
Abrir a pasta de trabalho do Excel a partir da pasta de instalação.
4.
Confirme se a caixa de mensagem aparece.
Passo-a-passo: Concedendo e removendo permissões para uma solução do Office Essa explicação passo a passo demonstra as noções básicas de segurança no Microsoft Visual Studio 2005 Tools for the Microsoft Office System. Durante este explicação passo a passo, você aprenderá como: •
Remova a configuração de segurança padrão.
•
Adicionar um novo conjunto de permissões.
•
Testar seu projeto. Pré-requisitos
Para concluir esta explicação passo a passo, será necessário: •
Visual Studio Tools for Office
•
Microsoft Office Excel 2003. Criando o projeto
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.
Para criar um novo projeto •
Criar um projeto de pasta de trabalho do Excel com o nome My Security Test. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
Visual C# Consolidado
112
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Security Test projeto para Solution Explorer. Adicionar código para trás a planilha Nesta etapa, você adicionará uma caixa de mensagem a um evento de inicialização da planilha.
Para adicionar uma caixa de mensagem a um evento de inicialização 1.
Verifique se a My Security Test.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.
2.
Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs,. e, em seguida clique View Code no menu de atalho
3.
Adicione o seguinte código para o Startup método dentro classe Sheet1 para mostrar uma caixa de mensagem durante a inicialização. C#
Na caixa Save Project de diálogo, digite C:\Walkthroughs na caixa Location.
6.
Clique em Save.
7.
Pressione F5 para executar o projeto. O Excel é iniciado e aparecerá a caixa de mensagem.
8.
Fechar a caixa de mensagem.
9.
Feche o Excel.
10. No designer do Visual Studio, localize e selecione na guia para My Security Test.xls. 11. Feche My Security Test.xls (a superfície do design de planilha Excel) no designer do Visual Studio. Feche todos os instâncias do Excel antes de alterar a diretiva de segurança. Quando você criado o projeto de pasta de trabalho do Excel, o assistente adicionado um novo grupo de código de segurança e um grupo de códigos filho à diretiva de segurança Runtime no nível do usuário. Em seguida, você removerá o grupo de códigos que criou o assistente. Remover o grupo de códigos padrão Localize e remova o grupo de código padrão que foi criado.
Para remover um grupo de códigos 1.
No Painel de Controle, abra Administrative Tools.
2.
Executar Microsoft .NET Framework 2.0 Configuration.
3.
No modo de exibição de árvore no lado esquerdo, expanda .NET Framework 2.0 Configuration,, expandir Runtime Security Policy, expandir User, expandir Code Groups, Expandido All_Code e My Computer expanda VSTOProjects. Não é um GUID para cada projeto tenha criado. Expanda cada GUID para ver o caminho para o documento associado.
4.
Clique com o botão direito do mouse o GUID de C:\Walkthroughs\My Security Test\My Security Test\bin\My Security Test.xls grupo de códigos, e, em seguida clique Delete no menu de atalho.
Visual C# Consolidado
113
Será exibida uma caixa de diálogo perguntando se você tiver certeza que deseja excluir este grupo de códigos. 5.
Clique em Yes.
6.
Voltar para Visual Studio, e pressione F5 para executar o projeto meu teste de segurança. Será exibida informando a atual política de segurança .NET permite que não não que a personalização para executar uma mensagem de erro.
7.
Clique em OK.
8.
Feche o Excel.
O conjunto não pode ser executado se ele não tiver permissão explícita na Diretiva de Segurança Microsoft .NET. Em seguida, conceda permissão para o conjunto usando um nome forte em vez de uma URL para prova. Dando um nome de alta segurança para o conjunto Um nome forte é geralmente mais seguro que uma URL como prova. Será criar e atribuir um nome forte o conjunto nas próximas etapas.
Para criar um nome forte 1.
No menu Project no Visual Studio, clique em My Security Test Properties.
2.
Clique na Signing guia.
3.
Selecione Sign the assembly.
4.
No, o Choose a strong name key file list clique New.
5.
Na caixa Create Strong Name Key de diálogo, digite SecurityTestKey na caixa Key file name.
6.
Desmarque a Protect my key file with a password caixa de seleção.
7.
Clique em OK. O arquivo SecurityTestKey.snk de chave aparece no Solution Explorer.
8.
No menu Build, clique em Build Solution Para criar o conjunto contra o par de chaves nome forte. Conceder confiança com base no nome de alta segurança
Agora adicionar um novo grupo de código para conceder confiança total para o conjunto com base no nome forte.
Para conceder confiança com base em nome forte 1.
Abra Microsoft .NET Framework 2.0 Configuration novamente.
2.
Clique com o botão direito do mouse no VSTOProjects nó e clique New no menu de atalho
3.
Digite o nome Security Test Strong Name para o novo grupo de códigos, e clique em Next.
4.
Na lista Choose the condition type for this code group, clique Strong Name.
5.
Clique em Import.
6.
Procure C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\My para Visual Basic ou C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\debug\My no C#, e clique em Open.
Visual C# Consolidado
114
7.
Clique em Next.
8.
Clique Next para aceitar o FullTrust conjunto de permissões e clique em Finish.
9.
Fechar Microsoft .NET Framework 2.0 Configuration. Testar o aplicativo
Agora você pode testar sua pasta de trabalho para certificar-se que seu código seja executado quando a pasta de trabalho é aberta.
Para testar sua pasta de trabalho 1.
Pressione F5 para executar o projeto.
2.
Confirme se a caixa de mensagem aparece.
Visual C# Consolidado
115
O WORD USANDO EXPLICAÇÕES PASSO-A-PASSO Walkthroughs fornecem instruções passo a passo para cenários comuns e são um bom lugar para começar aprendendo sobre Microsoft Visual Studio 2005 Tools for the Microsoft Office System. As orientações a seguir demonstram formas você pode usar as ferramentas do Microsoft Office 2003 para automatizar projetos Microsoft Office Word 2003, para implantar suas soluções, e para definir a segurança.
Walkthrough: Changing Document formatação usando controles CheckBox Essa explicação passo a passo demonstra os fundamentos básicos do uso controles em um documento do Microsoft Office Word 2003 para alterar a formatação de texto. Você usará Microsoft Visual Studio 2005 Tools for the Microsoft Office System para criar e adicionar código ao seu projeto. Para ver o resultado como uma amostra completa, consulte Exemplo de controles do Word. Durante este explicação passo a passo, você aprenderá como: •
Adicione texto e um controle a um documento.
•
Formate o texto quando uma opção é selecionada.
•
Testar seu projeto. Observação
As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •
Visual Studio Tools for Office
•
O Microsoft Office Word 2003. Criando o projeto
Neste procedimento, você irá criar projeto usando Visual Studio Tools for Office um documento do Word.
Para criar um novo projeto •
Criar um projeto Documento do Word com o nome My Word Formatting. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. Abre o novo documento do Word no designer e adiciona o My Word Formatting projeto para Solution Explorer o Visual Studio. Adicionar texto e controles ao documento do Word
Para essa explicação passo a passo, você precisará três caixas de seleção e algum texto em um Bookmark controle no documento do Word.
Visual C# Consolidado
116
Para adicionar três caixas de seleção 1. 2. 3. 4.
Verifique se o documento está aberto no designer visual studio. Na Common Controls guia e arraste-o para o documento. da Toolbox, arraste um CheckBox No menu View, selecione Properties Window. Certifique-se de que que Checkbox1 esteja visível na caixa de listagem Nome de objeto da janela Properties, e altere as propriedades a seguir:
Propriedade
Value (Valor)
Name
applyBoldFont
Text
Negrito
5.
Pressione Enter para mover o ponto de inserção abaixo da primeira caixa de seleção.
6.
Adicionar uma segunda caixa de seleção para o documento abaixo da ApplyBoldFont caixa de seleção e alterar as propriedades a seguir:
Propriedade
Value (Valor)
Name
applyItalicFont
Text
Itálico
7. 8.
Pressione Enter para mover o ponto de inserção abaixo da segunda caixa de seleção. Adicionar uma caixa de seleção terceira para o documento abaixo da ApplyItalicFont caixa de seleção e alterar as propriedades a seguir:
Propriedade
Value (Valor)
Name
applyUnderlineFont
Text
Sublinhado
9.
Você em seguida, será arrastar o Bookmark controle para o documento.
Observação Você também pode adicionar o Bookmark controle usando a Bookmark caixa de diálogo, encontrada no menu Insert.
Para adicionar texto e um controle indicador 1.
Mover o ponto de inserção abaixo os controles caixa de seleção e digite o seguinte texto no documento: Clique em uma caixa de seleção para alterar a formatação de texto.
2.
Na guia Word Controls na Toolbox, arraste um Bookmark controle para o documento. A Add Bookmark Control caixa de diálogo será exibida.
3.
Selecione o texto é adicionado ao documento e clique em OK. Um Bookmark controle denominado Bookmark1 é adicionado ao texto selecionado no documento.
4.
Certifique-se de que que Bookmark1 esteja visível na caixa de listagem Nome de objeto da janela Properties, e alterar a propriedade Nome para fontText.
Visual C# Consolidado
117
Em seguida, escreva o código para formatar o texto quando uma caixa de seleção é marcada ou desmarcada. Formatação a caixa de texto quando a verificação é checked ou Cleared Quando o usuário seleciona uma opção de formatação, alterar o formato do texto no documento.
Para alterar a formatação quando uma caixa de seleção é marcada 1. 2.
Clique com o botão direito do mouse ThisDocument no Solution Explorer, e, em seguida clique View Code no menu de atalho. No C# somente, adicionar as constantes a seguir para a ThisDocument classe: C# Copiar Código
const int WordTrue = -1; const int WordFalse = 0; 3.
Adicione o seguinte código ao manipulador Click de eventos da caixa applyBoldFont de seleção: C#
Em C#, adicione manipuladores de eventos para as caixas de texto para o Startup evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#
this.applyBoldFont.Click += new EventHandler(applyBoldFont_Click); this.applyItalicFont.Click += new EventHandler(applyItalicFont_Click); this.applyUnderlineFont.Click += new EventHandler(applyUnderlineFont_Click); Testar o aplicativo Agora você pode testar seu documento para certificar-se que o texto está formatado corretamente quando você marca ou desmarca uma caixa de seleção.
Para testar seu documento 1.
Pressione F5 para executar o projeto.
2.
Marque ou desmarque uma caixa de seleção.
Visual C# Consolidado
118
3.
Confirme que o texto está formatado corretamente. Próximas etapas
Essa explicação passo a passo mostra as noções básicas de usando caixas de seleção e programaticamente alterar texto formatação em documentos do Word. Aqui estão algumas tarefas que podem vie em seguida: •
Implantação do projeto. Para obter mais informações, consulte Como: Implantar arquivos de solução usando o Publish Wizard.
•
Usando um botão para preencher uma caixa de texto. Para obter mais informações, consulte Exibindo texto em uma caixa de texto em um documento usando um botão Walkthrough:.
Exibindo texto em uma caixa de texto em um documento usando um botão Walkthrough: Essa explicação passo a passo demonstra noções básicas de usando botões e caixas de texto em documentos do Microsoft Office Word 2003,, bem como usar Microsoft Visual Studio 2005 Tools for the Microsoft Office System para criar um projeto. Durante este explicação passo a passo, você aprenderá como: •
Adicionar controles ao documento do Word.
•
Preencher uma caixa de texto quando um botão é clicado.
•
Testar seu projeto. Observação
As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •
Visual Studio Tools for Office
•
O Microsoft Office Word 2003. Criando o projeto
Nesta etapa, você irá criar projeto usando Visual Studio Tools for Office um documento do Word.
Para criar um novo projeto •
Criar um projeto Documento do Word com o nome My Word Button. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. Abre o novo documento do Word no designer e adiciona o My Word Button projeto para Solution Explorer o Visual Studio. Adicionar controles ao documento do Word
Nesta seção, você adicionará um botão e uma caixa de texto para o documento Word.
Para adicionar um botão e uma caixa de texto 1. 2.
Verifique se o documento está aberto no designer visual studio. Na guia Common Controls da Toolbox, arraste um TextBox controle para o documento.
Visual C# Consolidado
119
Observação No Word, controles são ignorados na linha com texto por padrão. Você pode modificar, controles forma, bem como objetos forma, são inseridos na guia Edit da caixa Options de diálogo. 3.
No menu View, selecione Properties Window.
4.
Certifique-que TextBox1 está visível na caixa Properties drop-down janela e alterar a Name propriedade da caixa de texto para displayText.
5.
Arraste um Button controle para o documento e alterar as seguintes propriedades:
Propriedade
Value (Valor)
Name
insertText
Text
Inserir texto
Agora Escreva o código a ser executado quando o botão é clicado. Preencher a caixa de texto quando o botão É Clicked Sempre que o usuário clica no botão, Hello World! é acrescentada à caixa de texto.
Para escrever para a caixa de texto quando o botão é clicado 1. 2.
Na Solution Explorer, clique com o botão direito do mouse ThisDocument e, em seguida clique View Code no menu de atalho. Adicione o seguinte código ao manipulador Click de eventos do botão: C#
Em C#, adicione um manipulador de eventos para o botão para o Startup evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#
this.insertText.Click += new EventHandler(insertText_Click); Testar o aplicativo Agora você pode testar seu documento para certificar-se que a mensagem Hello World! aparece na caixa de texto quando você clica no botão.
Para testar seu documento 1.
Pressione F5 para executar o projeto.
2.
Clique no botão.
3.
Confirme que Hello World! aparece na caixa de texto. Próximas etapas
Essa explicação passo a passo mostra os fundamentos básicos do uso botões e caixas de texto em documentos do Word. Aqui estão algumas tarefas que podem vie em seguida: •
Implantando o projeto. Para obter mais informações, consulte Como: Implantar arquivos de solução usando o Publish Wizard.
•
Usando uma caixa de combinação para alterar a formatação. Para obter mais informações, consulte Walkthrough: Changing Document formatação usando controles CheckBox.
Visual C# Consolidado
120
Walkthrough: Criando menus de atalho para indicadores Essa explicação passo a passo demonstra a criação de menus de atalho para Bookmark controles. Você irá escrever código no evento BeforeRightClick do indicador para que quando o usuário clica com o botão direito do mouse o texto dentro do indicador, um menu de atalho contendo itens de menu para formatar o texto apareça. Durante este explicação passo a passo, você aprenderá como: •
Criar um menu de atalho.
•
Escrever código para responder a com o botão direito do mouse texto em um indicador.
•
Verifique se há sobreposição indicadores.
•
Testar seu projeto. Observação
As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •
Microsoft Visual Studio 2005 Tools for the Microsoft Office System
•
O Microsoft Office Word 2003. Criando o projeto
Nesta etapa, você irá criar um projeto Documento do Word no Visual Studio.
Para criar um novo projeto •
Criar um projeto Documento do Word com o nome My Bookmark Shortcut Menu. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. Abre o novo documento do Word no designer e adiciona o My Bookmark Shortcut Menu projeto para Solution Explorer o Visual Studio. Adicionar texto e indicadores ao documento
Nesta etapa, você será adicionar texto ao seu documento do Word e depois adicionar dois indicadores.
Para adicionar texto ao seu documento Digite o seguinte texto em um documento do Word:
•
Este é um Exemplo de criar um menu de atalho quando você clica com o botão direito do mouse texto em um indicador.
Para adicionar um controle indicador ao seu documento 1.
Na guia Word Controls da Toolbox, arraste um Bookmark controle para o documento. A Add Bookmark Control caixa de diálogo será exibida.
2.
Selecione as palavras creating a shortcut menu when you right-click the text no seu documento e clique em OK. é bookmark1 adicionado ao documento.
Visual C# Consolidado
121
3.
Adicionar outro Bookmark controle com as palavras right-click the text in a bookmark. é bookmark2 adicionado ao documento.
Observação As palavras right-click the text aparecerão no bookmark1 e bookmark2. Quando você adicionar indicadores aos seus documentos Office Word 2003 no tempo de criação, um Bookmark controle é criado que permite a você para programa contra vários eventos do indicador. Você pode escrever código no evento BeforeRightClick do indicador para que quando o usuário clica com o botão direito do mouse o texto dentro do indicador, um menu de atalho contendo itens de menu apareça. Criando o menu curto
Para criar o menu de atalho 1. 2.
No Solution Explorer, clique com o botão direito do mouse ThisDocument e selecione View Code. Declarar as CommandBar variáveis e uma variável do indicador no nível de classe: C#
Adicionar um showPopupMenu manipulador de eventos para manipular o BeforeRightClick evento de dois indicadores:
Observação Você deve escrever código para manipular o caso em que se sobrepõem indicadores. Se você não fizer isso, por padrão, o código se chamará para cada indicador dentro da seleção. C# private void showPopupMenu(object sender, Microsoft.Office.Tools.Word.ClickEventArgs e) { int startPosition = 0; // If bookmarks overlap, get bookmark closest to cursor. for (int i = 1; i <= e.Selection.Bookmarks.Count; i++) { object o = i; if (e.Selection.Bookmarks.get_Item(ref o).Start > startPosition) { startPosition = e.Selection.Bookmarks.get_Item(ref o).Start; } } // If closest bookmark is the sender, show the popup. if (((Word.Bookmark)sender).Start == startPosition) { selectedBookmark = (Microsoft.Office.Tools.Word.Bookmark)sender; commandBar.ShowPopup(missing, missing); e.Cancel = true; } } 3.
Em C#, você deve adicionar manipuladores de eventos para os controles do indicador ao Startup evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#
this.bookmark1.BeforeRightClick += new Microsoft.Office.Tools.Word. ClickEventHandler(showPopupMenu); this.bookmark2.BeforeRightClick += new Microsoft.Office.Tools.Word. ClickEventHandler(showPopupMenu); Testar o aplicativo Nesta seção, você irá testar seu documento para certificar-se de que os itens de menu negrito e itálico apareçam no menu de atalho quando clicar com o botão direito do mouse texto em um indicador e o texto que está formatado corretamente.
Para testar seu documento 1.
Pressione F5 para executar o projeto.
2.
Clique com o botão direito do mouse dentro do indicador e selecione Bold primeiro.
3.
Verificar se todos os o texto no bookmark1 é formatados como negrito.
4.
Clique com o botão direito do mouse dentro do texto dos indicadores sobrepostos e selecione Italic.
5.
Verificar se todos os o texto no bookmark2, mas somente essa parte do texto em bookmark1 que se sobreponha bookmark2 é formatados como itálico. Próximas etapas
Essa explicação passo a passo mostra como criar menus de atalho em indicadores. Aqui estão algumas tarefas que podem vie em seguida: •
Escrever código para responder a eventos de controles host no Excel. Para obter mais informações, consulte Programação contra eventos de um controle NamedRange Walkthrough:.
•
Use uma caixa de seleção para alterar formatação em um indicador. Para obter mais informações, consulte Walkthrough: Changing Document formatação usando controles CheckBox.
Visual C# Consolidado
123
Walkthrough: atualizando um gráfico em um documento usando botões de opção Essa explicação passo a passo demonstra os fundamentos básicos do alterando estilos do gráfico usando botões de opção em um documento do Microsoft Office Word 2003. Você usará Microsoft Visual Studio 2005 Tools for the Microsoft Office System para criar e adicionar código ao seu projeto. Para ver o resultado como uma amostra completa, consulte Exemplo de controles do Word. Durante este explicação passo a passo, você aprenderá como: •
Adicionar um gráfico a um documento.
•
Adicionar um controle de usuário a um documento.
•
Alterar o estilo do gráfico quando uma opção está selecionada.
•
Testar seu projeto. Observação
As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •
Visual Studio Tools for Office
•
O Microsoft Office Word 2003. Criando o projeto
Nesta etapa, você irá criar projeto usando Visual Studio Tools for Office um documento do Word.
Para criar um novo projeto •
Criar um projeto Documento do Word com o nome My Chart Options. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. Abre o novo documento do Word no designer e adiciona o My Chart Options projeto para Solution Explorer o Visual Studio. Adicionar um gráfico ao documento
Em seguida, adicione um gráfico para o documento.
Para adicionar um gráfico 1.
No menu Insert, clique em Object. A Object caixa de diálogo será aberta.
Observação Se o Insert menu não estiver visível, você deverá primeiro clicar em dentro do documento para que ele foco. Para obter mais informações consulte, Menus do Office no ambiente do Visual Studio. 2.
Na lista Object type da guia Create New, selecione Microsoft Graph Chart e clique em OK
Visual C# Consolidado
124
Um gráfico é adicionado ao documento no ponto de inserção, e a Datasheet janela é exibida com alguns dados padrão. 3.
Feche a Datasheet janela para aceite os valores padrão no gráfico e clique dentro do documento para mover foco fora do gráfico.
4.
Clique com o botão direito do mouse no gráfico e selecione Format Object.
5.
Na guia Layout da caixa de diálogo, selecione Square e Format Object Clique em OK. Adicionar um controle de usuário ao projeto
Para adicionar um controle de usuário 1.
Selecione o My Chart Options projeto no Solution Explorer.
2.
No menu Project, clique em Add New Item.
3.
Na caixa Add New Item de diálogo, clique User Control, nome do controle ChartOptions, e clique em Add
Para adicionar controles Windows Form ao controle de usuário 1.
Se o controle de usuário estiver não visível no designer, clique duas vezes em ChartOptions no Solution Explorer.
2.
Na guia Common Controls Da arraste um Radio Button controle para o controle de usuário, e alterar as seguintes propriedades: o Toolbox,
Propriedade
Value (Valor)
Name
columnChart
Text
Gráfico de coluna
3.
Adicionar um segundo Radio Button ao controle de usuário, e alterar as seguintes propriedades:
Propriedade
Value (Valor)
Name
barChart
Text
Gráfico de barras
4.
Adicionar um terceiro Radio Button ao controle de usuário, e alterar as seguintes propriedades:
Propriedade
Value (Valor)
Name
lineChart
Text
Gráfico de linha
5.
Adicionar um quarto Radio Button ao controle de usuário, e alterar as seguintes propriedades:
Propriedade
Value (Valor)
Name
areaBlockChart
Text
Gráfico bloquear de área Adicionar Referências
Visual C# Consolidado
125
Para acessar o gráfico do controle de usuário em um documento, você deve ter uma referência à 11.0 biblioteca objeto do Graph Microsoft no seu projeto.
Para adicionar uma referência à 11.0 biblioteca objeto do Graph Microsoft 1.
No menu Project, clique em Add Reference. A Add Reference caixa de diálogo será exibida.
2. 3.
Clique na COM guia. Selecione Microsoft Graph 11.0 Object Library na lista Component Name e clique em OK Alterar o estilo gráfico quando o botão de opção é selecionada
Nesta seção, você será criar um evento público sobre o controle de usuário, adicionar uma propriedade para definir o tipo de seleção, e criar um procedimento para o CheckedChanged evento de cada um dos botões de opção.
Para criar um evento e propriedade em um controle de usuário 1.
No Solution Explorer, clique com o botão direito do mouse no controle de usuário e selecione View Code.
2.
Adicione código para criar um SelectionChanged evento e a Selection propriedade para a ChartOptions classe: C#
public event EventHandler SelectionChanged; private Microsoft.Office.Interop.Graph.XlChartType selectedType = Microsoft.Office.Interop.Graph.XlChartType.xlColumnClustered; public Microsoft.Office.Interop.Graph.XlChartType Selection { get { return this.selectedType; } set { this.selectedType = value; } }
Para manipular o evento CheckedChange dos botões de opção 1.
Definir o tipo de gráfico no manipulador CheckedChanged de eventos de botão areaBlockChart de opção e depois gerar o evento. C#
Em C#, você deve adicionar manipuladores de eventos para os botões de opção. Adicione o código para o ChartOptions Construtor, sob a chamada para InitializeComponent, conforme mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#
public ChartOptions() { InitializeComponent(); areaBlockChart.CheckedChanged += new EventHandler(areaBlockChart_CheckedChanged); barChart.CheckedChanged += new EventHandler(barChart_CheckedChanged); columnChart.CheckedChanged += new EventHandler(columnChart_CheckedChanged); lineChart.CheckedChanged += new EventHandler(lineChart_CheckedChanged); } Adicionando o controle de usuário ao documento Quando você cria a solução, o novo controle de usuário é automaticamente adicionado à Toolbox. Do Toolbox Você pode, então, arrastar o controle de ao seu documento.
Para adicionar o controle de usuário do documento 1.
No menu Build, clique em Build Solution. O ChartOptions controle de usuário é adicionado à Toolbox.
2. 3.
Clique com o botão direito do mouse ThisDocument.vb no Solution Explorer, ou ThisDocument.cs. e selecione View Designer Do Toolbox arraste o ChartOptions controle de para o documento. Um novo controle chamado ChartOptions1 é adicionado ao seu projeto. Alterar o tipo de gráfico
Nesta seção, criar um manipulador de eventos para alterar o tipo de gráfico acordo para a opção selecionada no controle de usuário.
Para alterar o tipo de gráfico que é exibido no documento 1.
Adicionar o manipulador de eventos a seguir para a ThisDocument classe. C#
private void ChartOptions1_SelectionChanged(object sender, EventArgs e) { try { //first object is the runtime storage control object index = 2; Word.Shape shape = this.Shapes.get_Item(ref index); //Activate the shape shape.Activate(); Microsoft.Office.Interop.Graph.Chart dataChart = (Microsoft.Office.Interop.Graph.Chart)shape.OLEFormat.Object; dataChart.ChartType = this.ChartOptions1.Selection; //Deactivate the shape this.ChartOptions1.Select(); } catch (Exception ex) { MessageBox.Show(ex.Message); } } 2.
Em C#, adicione um manipulador de eventos para o controle de usuário para o Startup evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:.
Visual C# Consolidado
127
C# this.ChartOptions1.SelectionChanged += new EventHandler(ChartOptions1_SelectionChanged); Testar o aplicativo Agora você pode testar seu documento para certificar-se que o estilo do gráfico é atualizado corretamente quando você seleciona um botão de opção.
Para testar seu documento 1.
Pressione F5 para executar o projeto.
2.
Selecione vários botões de opção.
3.
Confirme que o estilo do gráfico altera para correspondem à seleção. Próximas etapas
Essa explicação passo a passo mostra noções básicas de usando botões de opção e programaticamente alterando estilos do gráfico em documentos do Word 2003. Aqui estão algumas tarefas que podem vie em seguida: •
Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:
•
Usando um botão para preencher uma caixa de texto. Para obter mais informações, consulte Exibindo texto em uma caixa de texto em um documento usando um botão Walkthrough:.
•
Alterar formatação, selecionando um estilo da caixa de combinação. Para obter mais informações, consulte Walkthrough: Changing Document formatação usando controles CheckBox.
Vinculação de Dados para controles em um painel Ações do Word Walkthrough: Essa explicação passo a passo demonstra vinculação de dados a controles em um painel Ações no Microsoft Office Word 2003. Os controles serão demonstram uma Relação mestre / detalhes entre tabelas em um banco de dados do SQL Server. Durante este explicação passo a passo, você aprenderá como: • •
Criar um controle painel Ações para o painel Ações. Adicionar controles que são acoplados a dados a um controle painel Ações Windows Forms.
•
Use uma Relação mestre / detalhes quando exibir dados nos controles.
•
Mostrar painel de ações quando abre o aplicativo.
•
Testar seu projeto. Observação
As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •
Microsoft Visual Studio 2005 Tools for the Microsoft Office System
Visual C# Consolidado
128
O Microsoft Office Word 2003.
•
Acesso a um servidor com o Exemplo de SQL Server do Northwind. Permissões para ler e gravar no banco de dados do SQL Server.
•
Criando o projeto Nesta etapa, você irá criar um projeto Documento do Word.
Para criar um novo projeto •
Criar um projeto Documento do Word com o nome My Word Actions Pane. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. Abre o novo documento do Word no designer e adiciona o My Word Actions Pane projeto para Solution Explorer o Visual Studio. Adicionar controles ao painel de ações
Para essa explicação passo a passo, é necessário um controle painel Ações que contém controles ligados a dados Windows Forms. Adicionar uma fonte de dados para o projeto, e arraste os controles a partir da Data Sources janela para o controle painel Ações.
Para adicionar um controle painel Ações 1.
Selecione o My Word Actions Pane projeto no Solution Explorer.
2.
No menu Project, selecione Add New Item.
3.
Na caixa Add New Item de diálogo, selecione Actions Pane Control, nomeá-la ActionsControl, e clique em Add
Para adicionar uma nova fonte de dados para o projeto 1.
Se a Data Sources janela não estiver visível, clique Show Data Sources no Data menu.
Observação Se Show Data Sources Clique dentro do documento do Word e marque novamente. não estiver disponível, 2. 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.
7.
Marque a caixa de seleção ao lado e Products tabelas. o Suppliers
8.
Clique em Finish.
O assistente adiciona a Suppliers tabela e Products Tabela à janela Data Sources. Ele também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer.
Para adicionar controles Windows Forms ligados a dados a um controle painel Ações Visual C# Consolidado
129
1.
Na janela Data Sources, expanda a Suppliers tabela.
2.
Clique na seta suspensa no nó Company Name, e selecione ComboBox.
3.
Arraste CompanyName da janela Data Sources para o controle painel Ações. Um ComboBox controle é criado no controle painel Ações. Ao mesmo tempo, nomeado SuppliersBindingSource, um adaptador de tabela, e um DataSet são adicionados ao projeto no bandeja de componentes. um BindingSource
Observação Um navegador de ligação também é adicionado para o bandeja de componentes e para o topo do controle painel Ações. Você removerá esse controle posteriormente no explicação passo a passo o. 4.
Mover a caixa de combinação para que ele seja sob o rótulo e alterar a Size propriedade 171, 21.
5.
Expandir a Products tabela na janela Data Sources.
6.
Clique na seta suspensa no nó ProductName, e selecione ListBox.
7.
Arraste ProductName para o controle painel Ações. Um ListBox controle é criado no controle painel Ações. Ao mesmo tempo, chamado ProductBindingSource e um adaptador de tabela são adicionados para o projeto no bandeja de componentes. um BindingSource
8.
Do SuppliersBindingNavigator Selecione na bandeja e Component pressione DELETE.
Observação Excluindo o SuppliersBindingNavigator faz não remover todos os o código que foi gerado para ele. Você pode remover este código. 9.
Mover a caixa de listagem para que ele seja sob o rótulo e alterar a Size propriedade 171,95.
10. Arraste controlar e colocá-lo a caixa de listagem abaixo. de para o painel Ações um Button o Toolbox 11. Clique com o botão direito do mouse clique Properties no menu de atalho, e altere as seguintes propriedades: o Button, Propriedade
Value (Valor)
Name
Inserir
Text
Inserir
12. Redimensionar o controle de usuário para ajustar os controles. Configurando a fonte de dados Nesta seção, você adicionará código ao Load Evento do controle painel Ações para preencher o controle com dados da DataTable. Do DataSource você irá então definir e DataMember propriedades para cada controle.
Para carregar o controle com dados No manipulador Load de eventos da classe ActionsControl, adicione o seguinte código:
Para definir propriedades de vinculação de dados do controle 1.
Selecione o CompanyNameComboBox controle.
2.
Na janela Properties, clique no botão para a direita da propriedade DataSource, e selecione SuppliersBindingSource.
3.
Na janela Properties, clique no botão para a direita da propriedade DisplayMember, e selecione CompanyName.
4.
Selecione o ProductNameListBox controle.
5.
Na janela Properties, clique no botão para a direita da propriedade DataSource, expanda SuppliersBindingSource, e selecione FK_Products_Suppliers.
6.
Na janela Properties, clique no botão para a direita da propriedade DisplayMember, e selecione ProductName. Adicionando um método para inserir dados em uma tabela
Nesta etapa, será ler os dados dos controles acoplados e preencher uma tabela em seu documento do Word. Primeiro, você irá criar um procedimento para formatar os títulos na tabela, e seguida, você adicionará o AddData método para criar e formatar uma tabela do Word.
Para formatar os títulos de tabela Na classe ActionsControl, crie um método para formatar os títulos da tabela. Adicione código conforme mostrado no Exemplo a seguir: C# static void SetHeadings(Microsoft.Office.Interop.Word.Cell tblCell, string text) { tblCell.Range.Text = text; tblCell.Range.Font.Bold = 1; tblCell.Range.ParagraphFormat.Alignment = Microsoft.Office.Interop.Word.WdParagraphAlignment.wdAlignParagraphCenter; }
Para criar a tabela Na classe ActionsControl, escreva não um método que criará uma tabela se um não existir, e adicionar dados a partir do painel Ações à tabela. Adicione código conforme mostrado no Exemplo a seguir. C# private void AddData(DataRow row, string companyName) { object missing = System.Type.Missing; // Create a table if it doesn't already exist. if (Globals.ThisDocument.Tables.Count == 0) { try { // Create a table. Microsoft.Office.Interop.Word.Table tbl = Globals.ThisDocument.Tables.Add (Globals.ThisDocument.Application.Selection.Range, 1, 4, ref missing, ref missing); // Insert headings. SetHeadings(tbl.Cell(1, 1), "Company Name"); SetHeadings(tbl.Cell(1, 2), "Product Name"); SetHeadings(tbl.Cell(1, 3), "Quantity"); SetHeadings(tbl.Cell(1, 4), "Unit Price"); } catch (Exception ex) { MessageBox.Show("Problem creating Products table: " + ex.Message, "Actions Pane", MessageBoxButtons.OK, MessageBoxIcon.Error); } } // Add data from data row to the table. Microsoft.Office.Interop.Word.Selection selection = Globals.ThisDocument.Application.Selection; if (selection.Tables.Count > 0) { Microsoft.Office.Interop.Word.Row newRow = Globals.ThisDocument.Tables[1].Rows.Add(ref missing); newRow.Range.Font.Bold = 0; newRow.Range.ParagraphFormat.Alignment = Microsoft.Office.Interop.Word.WdParagraphAlignment.wdAlignParagraphLeft; newRow.Cells[4].Range.ParagraphFormat.Alignment = Microsoft.Office.Interop.Word.WdParagraphAlignment.wdAlignParagraphRight; newRow.Cells[1].Range.Text = companyName; newRow.Cells[2].Range.Text =
Visual C# Consolidado
131
row["ProductName"].ToString(); newRow.Cells[3].Range.Text = row["QuantityPerUnit"].ToString(); newRow.Cells[4].Range.Text = Math.Round(Convert.ToDouble(row["UnitPrice"])).ToString("#,##0.00"); } else { MessageBox.Show("Cursor must be within a table.", "Actions Pane", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
Para inserir texto em uma tabela do Word No manipulador Click de eventos do botão Insert, adicione código conforme mostrado no Exemplo o seguir: Observação Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C# private void Insert_Click(object sender, System.EventArgs e) { DataTable tbl = northwindDataSet.Products; DataRow[] rows; // Check if a product is selected. if (this.productNameListBox.SelectedIndex >= 0) { DataRowView productRow =(System.Data.DataRowView)this.productNameListBox.SelectedItem; string product = productRow.Row["ProductName"].ToString(); string company = this.companyNameComboBox.Text; // Return the data row from the selected product. rows = tbl.Select("ProductName = '" + product.Replace("'", "''") + "'"); this.AddData(rows[0], company); } else { MessageBox.Show("Please select a product.", "Actions Pane", MessageBoxButtons.OK); } } 1.
Em C#, você deve criar um manipulador de eventos para o Click Evento do botão. Você pode colocar este código no manipulador Load de eventos da classe ActionsControl. Para obter mais informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C#
this.Insert.Click += new EventHandler(Insert_Click); Mostrando o Painel de Ações Você nesta seção, vai escrever código para mostrar o painel Ações. O painel Actions ficará visível depois controles são adicionados a ele.
Para mostrar o painel Ações 1.
Clique com o botão direito do mouse ThisDocument.vb no Solution Explorer, ou ThisDocument.cs,. e, em seguida clique View Code no menu de atalho
Criar uma nova instância do controle na parte superior da classe ThisDocument de forma que ele tenha como no Exemplo a seguir: C# private ActionsControl actions = new ActionsControl(); Adicione código ao manipulador Startup de eventos de ThisDocument forma que ele tenha como no Exemplo a seguir: Observação Para obter informações sobre como criar manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. C# this.ActionsPane.Controls.Add(actions); Testar o aplicativo
Visual C# Consolidado
132
Agora você pode testar seu documento para certificar-se que o painel Ações é aberto quando o documento for aberto. Teste para a relação mestre / detalhes nos controles no painel Ações, e certifique-se que dados são preenchidos em uma tabela do Word quando o Insert botão é clicado.
Para testar seu documento 1.
Pressione F5 para executar o projeto.
2.
Confirme se o painel Actions está visível.
3.
Selecione uma empresa na caixa de combinação e verifique que os itens na caixa Products Lista alterar.
4.
Selecione um produto, clique Insert no painel de ações, e verifique se os detalhes do produto foram adicionados à tabela no Word.
5.
Inserir outros produtos de várias empresas. Próximas etapas
Essa explicação passo a passo mostra as noções básicas de vinculação de dados a controles em um painel Ações no Word. Aqui estão algumas tarefas que podem vie em seguida: •
Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do Office:.
•
Ligação de dados a controles no Excel. Para obter mais informações, Vinculação de Dados para controles em um painel Ações do Excel Walkthrough:.
•
Mostrar e ocultar controles no painel de ações. Para obter mais informações, consulte Alterando o painel de ações de acordo com contexto do usuário Walkthrough:
Walkthrough: criar uma marca inteligente que converte Temperatures de Fahrenheit para Celsius Essa explicação passo a passo demonstra criar uma marca inteligente que reconhece Fahrenheit seqüências de temperatura. A marca inteligente inclui uma ação que converte o valor de temperatura em Celsius, e substitui o texto reconhecido por um Celsius formatado Seqüência de temperatura. Durante este explicação passo a passo, você aprenderá como: • •
Criar uma marca inteligente que reconhece uma expressão regular. Criar uma ação que recupera dados da marca inteligente e modifica o texto de reconhecido marca inteligente. Pré-requisitos
Para concluir esta explicação passo a passo, será necessário: •
Microsoft Visual Studio 2005 Tools for the Microsoft Office System
•
O Microsoft Office Word 2003. Criando um novo projeto
Nesta etapa, você irá criar um projeto Documento do Word.
Para criar um novo projeto •
Criar um projeto Documento do Word com o nome My Smart Tag, usando o Visual Basic ou C#. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
Abre o novo documento do Word no designer e adiciona o My Smart Tag projeto para Solution Explorer o Visual Studio.
Visual C# Consolidado
133
Configurando o projeto Para esta etapa, você irá configurar o projeto para executar o código fornecido nessa explicação passo a passo.
Para configurar seu projeto 1.
No menu Project, clique em Add Reference.
2.
Na guia COM, selecione biblioteca tipo 2.0 marcas inteligentes Microsoft e clique em OK.
3. 4.
No Solution Explorer, clique com o botão direito do mouse ThisDocument.vb (em Visual Basic) ou ThisDocument.cs (em C#) e clique em View Code. Adicione a seguinte linha de código para o topo do arquivo: C#
using System.Text.RegularExpressions; Criando a marca inteligente Nesta etapa, você será criar uma Visual Studio Tools for Office marca inteligente e adicioná-lo para o documento. Também irá adicionar uma expressão regular para a lista de termos que reconhece a marca inteligente, e criar uma ação que estará disponível quando o usuário clica a marca inteligente.
Para criar a marca inteligente 1.
Substituir manipulador ThisDocument_Startup de eventos na classe ThisDocument pelo código a seguir. Este código cria uma SmartTag que representa a Visual Studio Tools for Office marca inteligente, e adiciona uma expressão regular para a lista de termos que reconhece a marca inteligente. C#
Criar uma nova Action e adicioná-lo para a Actions propriedade da marca inteligente. A Action representa um item que o usuário pode clicar no menu de marcas inteligentes. C#
action1 = new Microsoft.Office.Tools.Word.Action( "Convert to Celsius"); smartTag1.Actions = new Microsoft.Office.Tools.Word.Action[] {action1}; 3.
Do SmartTag anexar a marca inteligente para o documento, adicionando à propriedade VSTOSmartTags. Na C#, anexar um manipulador de eventos para o Click evento da ação. C#
this.VstoSmartTags.Add(smartTag1); action1.Click += new Microsoft.Office.Tools.Word.ActionClickEventHandler( action1_Click); } Criar um manipulador de eventos para a ação Nesta etapa, você irá adicionar um manipulador de eventos para o Click evento da ação. O manipulador de eventos recupera o Fahrenheit valor de temperatura da chave number, que está no conjunto de propriedades da marca inteligente. O manipulador de eventos converte o Fahrenheit valor de temperatura para Celsius,. e substitui a seqüência reconhecido Neste exemplo, a chave number identifica um grupo capturado da expressão regular atribuído a marca inteligente. Para obter mais informações sobre propriedade Sacos e expressões regulares em Visual Studio Tools for Office marcas inteligentes, consulte Arquitetura marcas inteligentes.
Visual C# Consolidado
134
Para criar o manipulador de eventos Copie o código a seguir para a ThisDocument classe:
•
C# void action1_Click(object sender, Microsoft.Office.Tools.Word.ActionEventArgs e) { string value = e.Properties.get_Read("number"); double fahrenheit = Convert.ToDouble(value); int celsius = (int)(fahrenheit - 32) * 5 / 9; e.Range.Text = celsius.ToString() + "C"; } Testar o aplicativo Agora você pode testar seu documento para certificar-se que a marca inteligente converte Fahrenheit temperaturas para Celsius.
Para testar sua pasta de trabalho 1. 2.
Pressione F5 para executar o projeto. Digitar uma seqüência que esteja de acordo com a expressão regular é adicionado à marca inteligente, como 60F, 60° F,. ou 60 F
Observação Para digitar um símbolo de grau (°), pressione ALT e digite 248. 3.
Clique no ícone de marca inteligente que aparece sobre a seqüência reconhecida e clique em Convert to Celsius.
4.
Confirme que a seqüência original é substituída por uma nova seqüência contendo a temperatura em Celsius.
Implantando um Word ou Solution do Excel usando um manifesto Deployment Walkthrough: Essa explicação passo a passo demonstra como implantar uma solução o Microsoft Office Excel ou Microsoft Office Word em um compartilhamento de rede em um servidor. Será posicionado no final do explicação passo a passo, o possível para executar a solução no servidor do seu computador de desenvolvimento. Em um ambiente de produção, uma Microsoft Visual Studio 2005 Tools for the Microsoft Office System solução geralmente é publicada primeiro a um servidor de teste, e depois ele é reimplantado em um servidor de produção depois que o departamento de TI aprovar-. Você nessa explicação passo a passo, será emular esse processo, publicando uma solução em um local temporário no seu computador de desenvolvimento, e então redeploying a solução do local de publicação para um servidor. Para obter mais informações sobre as opções para implantar a solução, consulte Modelos de implantação. Durante este explicação passo a passo, você aprenderá como: •
Do Publish Wizard uso para publicar sua solução em um local no seu computador de desenvolvimento.
•
Manualmente relançamento a solução do seu computador local para um compartilhamento de rede em um servidor.
•
Modificar o manifesto do aplicativo que está incorporado no documento para apontar para o novo local manifesto de implantação programaticamente.
•
Editar a manifesto de implantação para apontar para a nova localização do manifesto do aplicativo externos.
•
Editar o manifesto do aplicativo externo para apontar para o novo local do conjunto e a manifesto de implantação. Pré-requisitos
Visual C# Consolidado
135
Para concluir esta explicação passo a passo, será necessário: •
Visual Studio Tools for Office
•
O Word Microsoft Office 2003 ou Microsoft Office Excel 2003. Observação
Essa explicação passo a passo pressupõe que você estiver implantando uma solução Word. Se você quiser executar explicação passo a passo com uma solução Excel, o substitua o nome do projeto do Word com o nome do seu projeto do Excel em todos os códigos e exemplos XML. •
Acesso a um servidor de rede para implantação. Essa explicação passo a passo pressupõe que você são redeploying sua solução para o \\DeployServer\ShareFolder compartilhamento de rede.
•
Privilégios de administrador no computador de desenvolvimento, para que você possa definir a diretiva de segurança para um local de rede. Criando o projeto
Nesta etapa, você irá criar um projeto Documento do Word.
Para criar um novo projeto •
Criar um projeto Documento do Word com o nome WordDeployment. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
Abre o novo documento do Word no designer e adiciona o WordDeployment projeto para Solution Explorer o Visual Studio. Adicionar código para trás o documento Nesta etapa, você adicionará uma caixa de mensagem ao manipulador Startup de eventos do documento. Isso permitirá que você para verificar se a solução está funcionando quando você abre o documento rapidamente.
Para adicionar uma caixa de mensagem a um evento de inicialização 1.
Clique com o botão direito do mouse ThisDocument.vb no Solution Explorer, ou ThisDocument.cs,. e, em seguida clique View Code no menu de atalho
2.
Adicione o seguinte código ao manipulador Startup de eventos dentro a ThisDocument classe para mostrar uma caixa de mensagem durante a inicialização. C#
Pressione F5 para executar o projeto. Inicia o Word e a caixa de mensagem aparece.
4.
Fechar a caixa de mensagem.
5.
Sair do Word.
Em seguida, você publicará nesta solução. Publicando a solução Nesta etapa, você publicará a solução em um local temporário no computador local.
Para publicar a solução 1.
Clique com o botão direito do mouse o nó de projeto no Solution Explorer.
2.
Clique Publish no menu de atalho.
Visual C# Consolidado
136
O Publish Wizard aparece. 3. 4.
Na caixa Specify the location to publish this application, digite C:\TestDeploy. Clique em Finish. O documento de Solução e manifesto de implantação são copiados para C:\TestDeploy. O conjunto de solução, atualizado manifesto do aplicativo, e cópias do documento de Solução e manifesto de implantação são copiadas para C:\TestDeploy\WordDeployment_1.0.0.0. Para obter mais informações, consulte Implantando o Word e Excel Solutions.
5.
Feche o WordDeployment projeto no Visual Studio.
Observação O conjunto não tem permissão para executar ainda, para que ele se você tentar executar a solução será lançar um erro. Você irá atualizar sua diretiva de segurança para conceder permissão de confiança total ao conjunto em uma etapa posterior. Quando você publicar uma solução, o manifesto do aplicativo incorporado no aponta de documento de solução para o caminho completo da manifesto de implantação. Se você relançamento os arquivos de solução para outro local, deverá atualizar o manifesto do aplicativo incorporado para apontar para a nova localização da manifesto de implantação. Você também deve atualizar a manifesto de implantação e o manifesto do aplicativo externo para apontar para os novos locais de arquivo. Atualizando o manifesto Application incorporados Para editar o manifesto do aplicativo incorporado, use a ServerDocument classe que Visual Studio Tools for Office fornece. Quando você usa a ServerDocument classe, você deve executar o código em um novo projeto (não a Visual Studio Tools for Office Solução), como um projeto de console, e o Visual Studio Tools for Office documento de solução deve ser fechado. Observação Inclui Visual Studio Tools for Office um Exemplo que demonstre como criar uma ferramenta que pode ser usada para editar o manifesto do aplicativo incorporado. Para obter mais informações, consulte Aplicativo Manifest Exemplo Editor.
Para atualizar o manifesto do aplicativo incorporado 1.
Criar um novo projeto Console Application.
2.
Do Microsoft.VisualStudio.Tools.Applications.Runtime Adicionar referências para e System.Windows.Forms montagens para este projeto.
3.
Abra o arquivo Program.cs ou Module1.vb, e adicione a seguinte Imports ou using instrução para o topo do arquivo. C#
using Microsoft.VisualStudio.Tools.Applications.Runtime; 4.
Copie o código a seguir para a Main função. Este código cria uma ServerDocument que fornece acesso ao manifesto do aplicativo incorporado de seu documento de solução. O código atribui o novo caminho manifesto de implantação para a DeployManifestPath propriedade, e salva e fecha o ServerDocument.. o ServerDocument C#
Pressione F5 para executar o projeto. Uma janela do console aparece rapidamente enquanto o manifesto do aplicativo incorporado está sendo atualizado, e fecha a janela do console. Atualizando o manifesto de implantação
Agora que você atualizou o manifesto do aplicativo incorporado no documento Visual Studio Tools for Office de solução, você deve atualizar a manifesto de implantação para apontar para a nova localização do manifesto do aplicativo externos.
Para atualizar a manifesto de implantação 1.
Abra a manifesto de implantação em um editor de texto, como o Bloco de notas. A manifesto de implantação é denominado WordDeployment.application, e está localizado na pasta C:\TestDeploy de publicação.
2.
Defina o codebase atributo do elemento como o caminho completo da localização implantação final do manifesto do aplicativo externos. Para obter mais informações, consulte Element (Visual Studio Tools for Office Reference).O atributo para essa explicação passo a passo deve aspecto como este:
3.
Salve e feche o arquivo manifesto de implantação. Atualizando o manifesto de aplicativos externos
Além disso, para atualizar a manifesto de implantação, você também deve editar o manifesto do aplicativo externo para apontar para os locais implantação final do conjunto de solução e a manifesto de implantação. Sempre que você publicar uma Visual Studio Tools for Office solução, um novo manifesto do aplicativo externo é gerado que aponta para a versão atual do conjunto de solução.
Para atualizar o manifesto do aplicativo externo 1.
Abra o manifesto do aplicativo em um editor de texto, como o Bloco de notas. O manifesto do aplicativo é denominado WordDeployment.dll.manifest, e está localizado na pasta C:\TestDeploy\WordDeployment_1.0.0.0 de publicação.
2.
Localize o elemento que está o filho do elemento , e defina o codebase atributo como o caminho completo da montagem de solução atual. Para obter mais informações, consulte Element (Visual Studio Tools for Office Reference).O atributo para essa explicação passo a passo deve aspecto como este:
3.
Localize o elemento que está o filho do elemento , e defina o codebase atributo para o caminho completo do manifesto de implantação. Para obter mais informações, consulte Element (Visual Studio Tools for Office Reference).O atributo para essa explicação passo a passo deve aspecto como este:
4.
Salve e feche o arquivo manifesto do aplicativo. Copiando os arquivos da solução para o servidor
Agora que você tiver editado os manifestos, você está pronto para copiar os arquivos de solução para o servidor.
Visual C# Consolidado
138
Para copiar os arquivos de solução para o servidor 1.
Crie uma WordDeployment_1.0.0.0 pasta sob a \\DeployServer\ShareFolder compartilhamento de arquivos de rede.
2.
Copiar o documento de Solução e a manifesto de implantação para \\DeployServer\ShareFolder.
3.
Copiar o conjunto de solução e o manifesto do aplicativo para \\DeployServer\ShareFolder\WordDeployment_1.0.0.0. Conceder confiança total para a pasta de rede
Para execute sua Visual Studio Tools for Office solução a partir da pasta de rede, você deve conceder confiança total para a pasta de rede na sua diretiva de segurança no computador de desenvolvimento. Você pode modificar a diretiva de segurança de um prompt de comando usando a ferramenta Diretiva de Segurança para Acesso ao Código (Caspol.exe). Para conceder confiança para um local de rede, você deve ter privilégios de administrador e você deverá alterar a diretiva de segurança no nível do computador. Observação Este procedimento é destinado a fim de executar essa explicação passo a passo. Não use este procedimento para conceder confiança a conjuntos ou diretórios se não tiver certeza que sejam segura e protegida. Para obter mais informações sobre concessão e remover permissões, consulte HOW TO: conceder permissões para pastas e montagens e Como remover permissões de pastas e montagens:.
Para conceder confiança total para a pasta de rede Digite o seguinte comando no prompt de comando Studio visual:
•
caspol -m -ag LocalIntranet_Zone -url \\DeployServer\ShareFolder\* FullTrust -n "Remote Deployment" -d "Deployment Walkthrough" Testando a solução Agora você pode testar sua solução para certificar-se que seu código seja executado quando você abre o documento a partir do computador de desenvolvimento.
Para testar a implantação 1. 2.
No computador de desenvolvimento, abra o WordDeployment.doc arquivo no \\DeployServer\ShareFolder\. Confirme se a caixa de mensagem aparece. Próximas etapas
Você também pode implantar a solução usando um arquivo do Microsoft Windows Installer (.msi). Para obter mais informações, consulte Implantando um Word ou Solution do Excel usando um arquivo do Windows Installer Walkthrough:.
Implantando um Word ou Solution do Excel usando um arquivo do Windows Installer Walkthrough: Essa explicação passo a passo demonstra como criar um arquivo do Microsoft Windows Installer (.msi) que pode ser usado para implantar uma solução Microsoft Office Excel 2003 ou Microsoft Office Word 2003. Durante este explicação passo a passo, você aprenderá como:
Visual C# Consolidado
139
•
Criar um projeto de instalação que você pode usar para criar um arquivo do Windows Installer.
•
Modifique o projeto de instalação para que o arquivo Windows Installer instala sua Microsoft Visual Studio 2005 Tools for the Microsoft Office System solução.
•
Adicionar uma etapa para o projeto de instalação para que Arquivo do Windows Installer edita o manifesto do aplicativo incorporados no Visual Studio Tools for Office documento de solução.
Essa explicação passo a passo pressupõe que o computador de destino já tiver os pré-requisitos instalados para executar Visual Studio Tools for Office soluções. Você cria o arquivo Windows Installer não o verificar ou instalar esses pré-requisitos. Para obter mais informações sobre os prérequisitos para executar Visual Studio Tools for Office soluções, consulte Como se preparar computadores de usuário final para executar soluções do Office:. Observação Conjuntos em Visual Studio Tools for Office Soluções devem ser concede confiança total na diretiva de segurança do usuário final antes da solução seja executado. O arquivo Windows Installer você criar nessa explicação passo a passo não Não implantar a diretiva de segurança necessário para executar a solução. Para obter mais informações sobre segurança em Visual Studio Tools for Office soluções, consulte Requisitos de segurança para executar soluções do Office e Práticas recomendadas para segurança no Office Solutions. Para obter informações sobre como configurar a diretiva de segurança por usuário final computadores, consulte Implantação de diretiva de segurança. Pré-requisitos Para concluir esta explicação passo a passo, será necessário: •
Visual Studio Tools for Office
•
O Word Microsoft Office 2003 ou Microsoft Office Excel 2003. Observação
Essa explicação passo a passo inclui etapas para criar uma solução simples que você pode usar em explicação passo a passo o Excel. Se você deseja executar o explicação passo a passo com uma solução Word ou Excel existente, começarão o explicação passo a passo no título criando o Project a instalação, " " e certifique-se substituir o nome ExcelDeployment do projeto com o nome do seu projeto em todos os exemplos de código e instruções. Criando o projeto Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.
Para criar um novo projeto •
Criar um projeto de pasta de trabalho do Excel com o nome ExcelDeployment. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o ExcelDeployment projeto para Solution Explorer. Adicionar código para trás a pasta de trabalho Nesta etapa, você adicionará uma caixa de mensagem ao manipulador Startup de eventos da pasta de trabalho. Isso permite que você para verificar se a solução está funcionando quando você abre o documento rapidamente.
Para adicionar uma caixa de mensagem a um evento de inicialização
Visual C# Consolidado
140
1.
Clique com o botão direito do mouse ThisWorkbook.vb no Solution Explorer, ou ThisWorkbook.cs,. e, em seguida clique View Code no menu de atalho
2.
Adicione o seguinte código ao manipulador Startup de eventos dentro a ThisWorkbook classe para mostrar uma caixa de mensagem durante a inicialização. C#
Pressione F5 para executar o projeto. O Excel é iniciado e aparecerá a caixa de mensagem.
4.
Fechar a caixa de mensagem.
5.
Saia do Excel.
Em seguida, você adicionará um projeto de instalação para sua solução. Criar um projeto de instalação Nesta etapa, você irá criar um projeto de instalação que você pode compilar para criar um arquivo do Windows Installer para sua solução. Para obter mais informações, consulte Configurar projetos.
Para criar um projeto de instalação para a solução 1.
Clique com o botão direito do mouse no nó na Solution Explorer solução.
2.
Aponte para Add no menu de atalho, e clique em New Project. A Add New Project caixa de diálogo será exibida.
3.
No painel Project types, expanda Other Project types e selecione Setup and Deployment.
4.
No painel Templates, selecione Setup project.
5.
Nome do projeto ExcelSetup.
6.
Clique em OK. O projeto instalação aparece no Solution Explorer. Por padrão, o arquivo que você irá criar usando este projeto instalação Windows Installer inclui uma caixa de diálogo que permite ao usuário final que especifique o local de instalação da solução. Para obter mais informações, consulte Caixa de diálogo interface do usuário da pasta de instalação. Adicionar o pasta de trabalho e assembly da solução para o Project da instalação
Nesta etapa, você adicionará a saída do projeto ExcelDeployment principal para o projeto de instalação. A saída do projeto ExcelDeployment principal consiste de pasta de trabalho e o conjunto de solução.
Para adicionar o documento e conjunto ao projeto de instalação 1.
Clique com o botão direito do mouse no ExcelSetup project nó em Solution Explorer.
2.
Selecione View no menu de atalho, e depois clique em File System.
3.
Clique com o botão direito do mouse Application Folder no painel esquerdo.
4.
Aponte para Add no menu de atalho, e clique em Project Output.
5.
Selecione ExcelDeployment na caixa Project.
6.
Selecione Primary output na lista de tipos de saída.
7.
Clique em OK.
Visual C# Consolidado
141
A saída do projeto e dependências aparecem no painel direito. 8.
No Solution Explorer, expanda Detected Dependencies sob o ExcelSetup nó de projeto.
9.
Clique com botão direito mouse cada dependência, exceto para Microsoft .NET Framework, e clique Exclude no menu de atalho. Criar um projeto de ação personalizada
Nesta etapa, você irá criar um projeto que contém ações personalizadas para o projeto de instalação. Ações personalizadas são um recurso do Windows Installer que permitem a você para executar código no final de uma instalação para executar ações que não podem ser executadas durante a instalação. Para obter mais informações, consulte Ações Personalizadas.
Para criar um projeto ação personalizada 1.
Clique com o botão direito do mouse no nó na Solution Explorer solução.
2.
Aponte para Add no menu de atalho, e clique em New Project. A Add New Project caixa de diálogo será exibida.
3.
No painel Project types, expanda o nó para a linguagem de programação, e selecione Windows.
4.
No painel Templates, selecione Class Library.
5.
Nome do projeto ExcelCustomAction.
6.
Clique em OK. O novo projeto aparece na Solution Explorer.
7.
No Solution Explorer, clique com o botão direito do mouse Class1.vb ou Class1.cs sob o ExcelCustomAction projeto e, em seguida, clique em Delete. Este arquivo é desnecessário para essa explicação passo a passo. Criar uma ação personalizada que salvas o manifesto de aplicativo
Quando você executava seu projeto anteriormente nessa explicação passo a passo pelo pressionamento F5, a processo de criação editado o manifesto do aplicativo incorporado na pasta de trabalho para aponte para o caminho relativo do conjunto. Se a pasta de trabalho e o conjunto permanecer na mesma pasta após a instalação, então você não precisam modificar o manifesto do aplicativo incorporado, e você pode ignorar esta seção. No entanto, se você quiser que o usuário possa mover a pasta de trabalho para uma pasta diferente após a instalação, você deve editar o manifesto do aplicativo para apontar para o caminho completo da montagem. Você deve atualizar o manifesto do aplicativo que está incorporado no Visual Studio Tools for Office documento de Solução ao executar uma ação personalizada após a instalação, porque o local do conjunto de solução é desconhecido até que o usuário especifica o local durante a instalação. Editar o manifesto do aplicativo incorporado, usando a ServerDocument classe. Para usar a ServerDocument classe no projeto de instalação, adicione código para uma Installer classe dentro do projeto ação personalizada.
Para criar uma ação personalizada que edita o manifesto do aplicativo 1.
Clique com o ExcelCustomAction projeto no Solution Explorer.
2.
Aponte para Add no menu de atalho, e clique em New Item. A Add New Item caixa de diálogo será exibida.
3. 4.
Selecionar Installer Class, e nome da classe ManifestEditor. Adicione uma referência ao conjunto Microsoft.VisualStudio.Tools.Applications.Runtime para o ExcelCustomAction projeto.
Visual C# Consolidado
142
5. 6.
Do ManifestEditor.cs clique com o botão direito do mouse no Solution Explorer, ou ManifestEditor.vb arquivo e clique em View Code. Adicione a instrução seguinte Imports ou using para o topo do arquivo de código. C#
using Microsoft.VisualStudio.Tools.Applications.Runtime; 7.
Copie o código a seguir para a ManifestEditor classe. Esse código substitui o Install método, que é usado para executar ações Instalação personalizada. O código define o local de instalação especificado pelo usuário para a AssemblyPath propriedade. O caminho de instalação especificado pelo usuário e os nomes do documento e conjunto são obtidas a partir da Parameters propriedade. C#
// Override the Install method to update the customization location // in the application manifest. public override void Install(System.Collections.IDictionary stateSaver) { UpdateApplicationManifest(); base.Install(stateSaver); } // Update the application manifest according to the the install location. private void UpdateApplicationManifest() { // Get the parameters passed to the task. string targetDir = this.Context.Parameters["targetdir"]; string documentName = this.Context.Parameters["documentname"]; string assemblyName = this.Context.Parameters["assemblyname"]; // Get the application manifest from the document. string documentPath = System.IO.Path.Combine(targetDir, documentName); ServerDocument serverDocument1 = new ServerDocument(documentPath, System.IO.FileAccess.ReadWrite); try { AppManifest appManifest1 = serverDocument1.AppManifest; string assemblyPath = System.IO.Path.Combine(targetDir, assemblyName); appManifest1.Dependency.AssemblyPath = assemblyPath; serverDocument1.Save(); } finally { if (serverDocument1 != null) { serverDocument1.Close(); } } } 8.
Clique com o ExcelCustomAction projeto no Solution Explorer, e, em seguida clique em Build. Adicionando a ação personalizada ao projeto de instalação
Nesta etapa, você adicionará a saída do projeto ExcelCustomAction principal para o projeto de instalação. Isso permite que o arquivo Windows Installer para executar a ação personalizada que edita o manifesto do aplicativo.
Para adicionar a saída primária do projeto ação personalizada ao projeto de instalação 1. 2. 3.
Clique com o botão direito do mouse no ExcelSetup project nó em Solution Explorer. Aponte para View no menu de atalho, e clique em Custom Actions. O Custom Actions Editor, clique com botão direito no nó e Install Clique em Add Custom Action.
4.
Na caixa Look In Selecionar Application Folder, e clique em Add Output
5.
Selecione ExcelCustomAction na caixa Project.
6.
Selecione Primary output na lista de tipos de saída, e depois clique em OK.
7. 8. 9.
Verifique que Primary output from ExcelCustomAction (Active) foi adicionado à lista de saídas primária para o projeto de instalação e clique em OK Em expandir Install. o Custom Actions Editor, Clique com o botão direito do mouse Primary output from ExcelCustomAction (Active) e, em seguida clique em Properties Window.
Visual C# Consolidado
143
10. Na janela Properties, defina a CustomActionData propriedade para a seguinte seqüência: /targetdir="[TARGETDIR]/" /documentname="ExcelDeployment.xls" /assemblyname="ExcelDeployment.dll" Para obter informações sobre a CustomActionData propriedade, consulte Propriedade CustomActionData. 11. Clique com o botão direito do mouse e, em seguida clique em Build. Em Solution Explorer, o ExcelSetup project Teste a instalação Agora você pode testar a solução para garantir que sua solução é instalada quando você executar o arquivo do Windows Installer no seu computador de desenvolvimento.
Para testar a instalação 1.
Clique com o botão direito do mouse e, em seguida clique em Run. Em Solution Explorer, o ExcelSetup project
2.
Siga as instruções no Assistente de Instalação, e especificar uma pasta de instalação no seu computador de desenvolvimento.
3.
Abrir a pasta de trabalho do Excel a partir da pasta de instalação.
4.
Confirme se a caixa de mensagem aparece.
Passo-a-passo: Concedendo e removendo permissões para uma solução do Office Essa explicação passo a passo demonstra as noções básicas de segurança no Microsoft Visual Studio 2005 Tools for the Microsoft Office System. Durante este explicação passo a passo, você aprenderá como: •
Remova a configuração de segurança padrão.
•
Adicionar um novo conjunto de permissões.
•
Testar seu projeto. Pré-requisitos
Para concluir esta explicação passo a passo, será necessário: •
Visual Studio Tools for Office
•
Microsoft Office Excel 2003. Criando o projeto
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.
Para criar um novo projeto •
Criar um projeto de pasta de trabalho do Excel com o nome My Security Test. Verifique que Create a new document está selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Security Test projeto para Solution Explorer. Adicionar código para trás a planilha Nesta etapa, você adicionará uma caixa de mensagem a um evento de inicialização da planilha.
Para adicionar uma caixa de mensagem a um evento de inicialização Visual C# Consolidado
144
1.
Verifique se a My Security Test.xls pasta de trabalho é aberta no designer visual studio, com Sheet1 exibido.
2.
Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs,. e, em seguida clique View Code no menu de atalho
3.
Adicione o seguinte código para o Startup método dentro classe Sheet1 para mostrar uma caixa de mensagem durante a inicialização. C#
Na caixa Save Project de diálogo, digite C:\Walkthroughs na caixa Location.
6.
Clique em Save.
7.
Pressione F5 para executar o projeto. O Excel é iniciado e aparecerá a caixa de mensagem.
8.
Fechar a caixa de mensagem.
9.
Feche o Excel.
10. No designer do Visual Studio, localize e selecione na guia para My Security Test.xls. 11. Feche My Security Test.xls (a superfície do design de planilha Excel) no designer do Visual Studio. Feche todos os instâncias do Excel antes de alterar a diretiva de segurança. Quando você criado o projeto de pasta de trabalho do Excel, o assistente adicionado um novo grupo de código de segurança e um grupo de códigos filho à diretiva de segurança Runtime no nível do usuário. Em seguida, você removerá o grupo de códigos que criou o assistente. Remover o grupo de códigos padrão Localize e remova o grupo de código padrão que foi criado.
Para remover um grupo de códigos 1.
No Painel de Controle, abra Administrative Tools.
2.
Executar Microsoft .NET Framework 2.0 Configuration.
3.
No modo de exibição de árvore no lado esquerdo, expanda .NET Framework 2.0 Configuration,, expandir Runtime Security Policy, expandir User, expandir Code Groups, Expandido All_Code e My Computer expanda VSTOProjects. Não é um GUID para cada projeto tenha criado. Expanda cada GUID para ver o caminho para o documento associado.
4.
Clique com o botão direito do mouse o GUID de C:\Walkthroughs\My Security Test\My Security Test\bin\My Security Test.xls grupo de códigos, e, em seguida clique Delete no menu de atalho. Será exibida uma caixa de diálogo perguntando se você tiver certeza que deseja excluir este grupo de códigos.
5.
Clique em Yes.
6.
Voltar para Visual Studio, e pressione F5 para executar o projeto meu teste de segurança.
Visual C# Consolidado
145
Será exibida informando a atual política de segurança .NET permite que não não que a personalização para executar uma mensagem de erro. 7.
Clique em OK.
8.
Feche o Excel.
O conjunto não pode ser executado se ele não tiver permissão explícita na Diretiva de Segurança Microsoft .NET. Em seguida, conceda permissão para o conjunto usando um nome forte em vez de uma URL para prova. Dando um nome de alta segurança para o conjunto Um nome forte é geralmente mais seguro que uma URL como prova. Será criar e atribuir um nome forte o conjunto nas próximas etapas.
Para criar um nome forte 1.
No menu Project no Visual Studio, clique em My Security Test Properties.
2.
Clique na Signing guia.
3.
Selecione Sign the assembly.
4.
No, o Choose a strong name key file list clique New.
5.
Na caixa Create Strong Name Key de diálogo, digite SecurityTestKey na caixa Key file name.
6.
Desmarque a Protect my key file with a password caixa de seleção.
7.
Clique em OK. O arquivo SecurityTestKey.snk de chave aparece no Solution Explorer.
8.
No menu Build, clique em Build Solution Para criar o conjunto contra o par de chaves nome forte. Conceder confiança com base no nome de alta segurança
Agora adicionar um novo grupo de código para conceder confiança total para o conjunto com base no nome forte.
Para conceder confiança com base em nome forte 1.
Abra Microsoft .NET Framework 2.0 Configuration novamente.
2.
Clique com o botão direito do mouse no VSTOProjects nó e clique New no menu de atalho
3.
Digite o nome Security Test Strong Name para o novo grupo de códigos, e clique em Next.
4.
Na lista Choose the condition type for this code group, clique Strong Name.
5.
Clique em Import.
6.
Procure C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\My para Visual Basic ou C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\debug\My no C#, e clique em Open.
7.
Clique em Next.
8.
Clique Next para aceitar o FullTrust conjunto de permissões e clique em Finish.
9.
Fechar Microsoft .NET Framework 2.0 Configuration. Testar o aplicativo
Visual C# Consolidado
146
Agora você pode testar sua pasta de trabalho para certificar-se que seu código seja executado quando a pasta de trabalho é aberta.
Para testar sua pasta de trabalho 1.
Pressione F5 para executar o projeto.
2.
Confirme se a caixa de mensagem aparece.
COMO: Adicionar Controles a Documentos do Office Um controle é um componente no documento usado para exibir informações ou aceitar entrada do usuário. Você pode adicionar controles Windows Forms para o Microsoft Office Excel 2003 e Microsoft Office Word 2003 documentos em tempo de criação ou em tempo de execução. Por exemplo, você pode adicionar um ComboBox controle a sua planilha para que os usuários possa selecionar em uma lista de opções. Você também pode adicionar controles host, como controles Bookmark e NamedRange controles, para documentos do Office. Para obter mais informações, consulte Controles host do Word e Controles host do Excel. Observação As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio. Adicionando controles em tempo de design
Para arrastar um Windows Forms controle para o documento 1.
Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no Visual Studio para que o documento fique visível no designer. Para obter informações sobre como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
2.
Na guia Common Controls Da Clique no controle que você deseja adicionar e arrasteo para o documento. o Toolbox,
Observação Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","") no Formula Bar. Este texto é necessário e não devem ser excluídos.
Para desenhar um Windows Forms controle sobre o documento 1.
Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no Visual Studio para que o documento fique visível no designer. Para obter informações sobre como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
2.
Na guia Common Controls da caixa de ferramentas, clique no controle você deseja adicionar.
3.
No documento, clique no local em que a extremidade superior esquerda do controle para ser localizado, e arraste para onde você deseja o canto inferior-direito do controle seja localizado. O controle é adicionado para o documento com o local especificado e tamanho.
Observação Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","") no Formula Bar. Este texto é necessário e não devem ser excluídos.
Visual C# Consolidado
147
Para adicionar um controle Windows Forms para o documento clicando uma única vez sobre o controle 1.
Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no Visual Studio para que o documento fique visível no designer. Para obter informações sobre como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
2.
Na guia Common Controls Da clique Toolbox, o controle você deseja adicionar
3.
Um documento, clique onde desejar o controle a ser adicionado. O controle é adicionado ao documento com o tamanho padrão.
Observação Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","") no Formula Bar. Este texto é necessário e não devem ser excluídos.
Para adicionar um controle Windows Forms para o documento clicando duas vezes no controle 1.
Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no Visual Studio para que o documento fique visível no designer. Para obter informações sobre como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
2.
Na guia Common Controls Controle você deseja para adicionar de clique duplo no Toolbox. O controle é adicionado para o documento no centralizar do documento ou painel ativo.
Observação Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","") no Formula Bar. Este texto é necessário e não devem ser excluídos.
Para adicionar um controle Windows Forms para o documento, pressionando a tecla ENTER 1.
Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no Visual Studio para que o documento fique visível no designer. Para obter informações sobre como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do Office:.
2.
Na guia Common Controls Da Clique no controle que você deseja adicionar e pressione a tecla ENTER. o Toolbox, O controle é adicionado para o documento no centralizar do documento ou painel ativo.
Observação Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","") no Formula Bar. Este texto é necessário e não devem ser excluídos. Você também pode adicionar controles Windows Forms dinamicamente a um documento em tempo de execução usando os métodos auxiliar fornecidos pelo Microsoft Visual Studio 2005 Tools for the Microsoft Office System. No Exemplo abaixo, à célula A1 de um projeto de aplicativo Excel. é adicionado um Button Para obter informações sobre como adicionar outros controles Windows Forms, consulte Adicionar controles a documentos do Office em tempo de execução. Adicionando controles em tempo de execução
Para adicionar um Windows Forms controlar programaticamente
Visual C# Consolidado
148
•
No manipulador Startup de eventos de ThisWorkbook, insira o código a seguir para adicionar à célula C5: um Button C# private void Sheet1_Startup(object sender, System.EventArgs e) { Microsoft.Office.Tools.Excel.Controls.Button salesButton; salesButton = this.Controls.AddButton(this.get_Range("C5", missing), "salesButton"); salesButton.Text = "Calculate Total Sales"; }
COMO: Executar Cálculos do Excel por Programação O Calculate método executa todos os cálculos no objeto especificado. Use o método do objeto que limita o intervalo de cálculo para o menor número de células que você deseja recalcular. O mecanismo de recálculo do Microsoft Office Excel 2003 é muito rápido, mas se você pode limitar o número de células envolvidas, você pode otimizar a operação. Executar cálculos para um intervalo
Para executar cálculos em um controle NamedRange 1.
Chame o Calculate método do intervalo especificado. C# NamedRange1.Calculate();
Executar cálculos para o aplicativo inteiro Para executar cálculos em todas as pastas de trabalho abertas Chame o Calculate método do objeto Application.
•
C# this.Application.Calculate(); Compilando o código •
Este código deve ser colocado em uma classe folha, não na classe ThisWorkbook.
Como: Criar menus do Office programaticamente Este Exemplo cria um menu chamado New Menu na barra de menus do Microsoft Office Excel 2003. O novo menu é colocado à esquerda do menu Help. Ele contém um comando de menu. Quando o comando de menu for clicado, texto será inserido em uma célula na Sheet1. Para obter um Exemplo de personalização interface de usuário no Microsoft Office Word 2003, consulte COMO: Criar Barras de Ferramentas do Office por Programação e Walkthrough: Criando menus de atalho para indicadores. Adicione o seguinte código à classe ThisWorkbook. Observação Defina a Tag propriedade nos controles quando você adiciona manipuladores de eventos. Office usa a Tag propriedade para manter controle de manipuladores de eventos para um específico
Visual C# Consolidado
149
CommandBarControl. Se a Tag propriedade estiver em branco, os eventos não são tratados corretamente.
Observação Declarar o variáveis menu no nível de classe INSTEAD OF dentro o método onde eles são chamados. Isso garante que as variáveis menu permanecerá no escopo, desde que o aplicativo está sendo executado. Caso contrário, o item será removido do coleta de lixo em algum momento indeterminado, e seu código do manipulador de eventos pára de funcionar. Exemplo C# // Declare the menu variable at the class level. private Office.CommandBarButton menuCommand; private string menuTag = "A unique tag"; // Call AddMenu from the Startup event of ThisWorkbook. private void ThisWorkbook_Startup(object sender, System.EventArgs e) { CheckIfMenuBarExists(); AddMenuBar(); } // If the menu already exists, remove it. private void CheckIfMenuBarExists() { try { Office.CommandBarPopup foundMenu = (Office.CommandBarPopup) this.Application.CommandBars.ActiveMenuBar.FindControl( Office.MsoControlType.msoControlPopup, System.Type.Missing, menuTag, true, true); if (foundMenu != null) { foundMenu.Delete(true); } } catch (Exception ex) { MessageBox.Show(ex.Message); } } // Create the menu, if it does not exist. private void AddMenuBar() { try { Office.CommandBarPopup cmdBarControl = null; Office.CommandBar menubar = (Office.CommandBar)Application.CommandBars.ActiveMenuBar; int controlCount = menubar.Controls.Count; string menuCaption = "&New Menu"; // Add the menu. cmdBarControl = (Office.CommandBarPopup)menubar.Controls.Add( Office.MsoControlType.msoControlPopup, missing, missing, controlCount, true); if (cmdBarControl != null) { cmdBarControl.Caption = menuCaption; // Add the menu command. menuCommand = (Office.CommandBarButton)cmdBarControl.Controls.Add( Office.MsoControlType.msoControlButton, missing, missing, missing, true); menuCommand.Caption = "&New Menu Command"; menuCommand.Tag = "NewMenuCommand"; menuCommand.FaceId = 65; menuCommand.Click += new Microsoft.Office.Core._CommandBarButtonEvents_ClickEventHandler( menuCommand_Click); } } catch (Exception e) { MessageBox.Show(e.Message); } } // Add text to cell A1 when the menu is clicked. private void menuCommand_Click(Microsoft.Office.Core.CommandBarButton Ctrl, ref bool CancelDefault) { Globals.Sheet1.Range["A1", missing].Value2 = "The menu command was clicked."; }
COMO: Criar Barras de Ferramentas do Office por Programação Este Exemplo cria uma barra de ferramentas denominada Teste no Microsoft Office Word 2003. Ele aparece perto no meio do documento e contém dois botões. Quando um botão é clicado, uma caixa de mensagem aparece. Para obter um Exemplo de personalização a interface do usuário do Office no Microsoft Office Excel 2003, consulte Como: Criar menus do Office programaticamente. Adicione o seguinte código à classe ThisDocument. Observação Declarar o variáveis barra de comando no nível de classe INSTEAD OF dentro o método onde eles são chamados. Isso garante que as variáveis barra comando permanecerá no escopo, desde que o aplicativo está sendo executado. Caso contrário, o item será removido do lixo e seu código do manipulador de eventos não é executado. Exemplo C#
Visual C# Consolidado
150
// Create the command bar variables at the class level. Office.CommandBar commandBar; Office.CommandBarButton firstButton; Office.CommandBarButton secondButton; private void ThisDocument_Startup(object sender, System.EventArgs e) { AddToolbar(); } private void AddToolbar() { try { commandBar = Application.CommandBars["Test"]; } catch (ArgumentException e) { // Toolbar named Test does not exist so we should create it. } if (commandBar == null) { // Add a commandbar named Test. commandBar = Application.CommandBars.Add("Test", 1, missing, true); } try { // Add a button to the command bar and an event handler. firstButton = (Office.CommandBarButton)commandBar.Controls.Add(1, missing, missing, missing, missing); firstButton.Style = Office.MsoButtonStyle.msoButtonCaption; firstButton.Caption = "button 1"; firstButton.Tag = "button1"; firstButton.Click += new Office._CommandBarButtonEvents_ClickEventHandler(ButtonClick); // Add a second button to the command bar and an event handler. secondButton = (Office.CommandBarButton)commandBar.Controls.Add(1, missing, missing, missing, missing); secondButton.Style = Office.MsoButtonStyle.msoButtonCaption; secondButton.Caption = "button 2"; secondButton.Tag = "button2"; secondButton.Click += new Office._CommandBarButtonEvents_ClickEventHandler(ButtonClick); commandBar.Visible = true; } catch (ArgumentException e) { MessageBox.Show(e.Message); } } // Handles the event when a button on the new toolbar is clicked. private void ButtonClick(Office.CommandBarButton ctrl, ref bool cancel) { MessageBox.Show("You clicked: " + ctrl.Caption); }
Visual C# Consolidado
151
DESENVOLVIMENTO CORPORATIVO (VISUAL C#) Você pode programar em C# para desenvolver uma variedade de aplicativos corporativos, executando em arquiteturas baseadas em servidor e produtos de servidor. A seção Servidores e desenvolvimento da empresa da biblioteca MSDN contém a orientação de arquitetura, informações de padrões e práticas, e documentação e artigos técnicos sobre o uso dos produtos de servidor Microsoft, incluindo: •
O Microsoft SQL Server
•
Microsoft BizTalk Server
•
Servidor Microsoft Commerce
•
Microsoft Content Management Server
•
Microsoft Exchange Server
•
Microsoft Host Integration Server
•
Microsoft Internet Security and Acceleration Server 2000
•
Microsoft Business Solutions
•
Microsoft MapPoint
•
Microsoft Speech Server
PROGRAMAÇÃO DO TABLET PC (VISUAL C#) O Tablet PC é um computador pessoal suportado pelo Microsoft ® Windows ® XP que é voltado para aplicativos que permitem a entrada por “ink”, caneta e voz. A combinação de software e hardware em um Tablet PC permite esses métodos de interação do usuário e permite que uma experiência de computação para usuários rica, interativa e produtiva. A plataforma Tablet PC engloba o Windows XP e suas extensões que permitem entrada e saída de dados de texto manuscrito e voz em um Tablet PC assim como o intercâmbio desses dados com outros computadores. Para obter mais informações, consulte Windows XP Tablet PC Edition no MSDN Online e o Centro de Desenvolvimento Tablet e Mobile PC.
ÁUDIO, VÍDEO, JOGOS E ELEMENTOS GRÁFICOS (VISUAL C#) Você pode usar o Visual C# para criar aplicativos multimídia baseados no DirectX para tecnologias Windows Media e Código Gerenciado. O DirectX gerenciado Microsoft® DirectX® é um conjunto avançado de interfaces de programação (API) de aplicativo multimídia incorporados ao sistemas operacionais Microsoft Windows®. O DirectX fornece uma plataforma de desenvolvimento padrão para PCs baseados no Windows permitindo aos desenvolvedores de software acessarem recursos de hardware especializado sem precisar escrever códigos específicos de hardware. Essa tecnologia primeiro foi apresentada em 1995 e é
Visual C# Consolidado
152
um padrão reconhecido para o desenvolvimento de aplicativos de multimídia na plataforma Windows. DirectX é uma tecnologia do Windows que permite maior desempenho em gráficos, incluindo elementos gráficos em quatro cores, vídeo, e animação 3D, e som, incluindo som surround, quando você está executando jogos ou assistindo vídeo no seu PC. Para obter mais informações sobre o uso do DirectX em aplicativos C#, consulte DirectX 9.0 para código gerenciado no MSDN Online e o Microsoft DirectX Developer Center. O Windows Media Player O controle Windows Media Player ActiveX pode ser usado em aplicativos C# para adicionar capacidade de reprodução de áudio e vídeo. O Microsoft Windows Media Player 10 Software Development Kit (SDK) fornece informações e ferramentas para personalizar o Windows Media Player e para usar o controle Windows Media Player ActiveX. O SDK inclui documentação e exemplos de códigos mostrando como usar o controle Media Player ActiveX de um aplicativo C#. Para mais informações, consulte O Windows Media Player 10 SDK no MSDN Online. Windows Media Encoder O Windows Media Encoder 9 Series SDK pode ser programado usando C# para executar os seguintes tipos de tarefas: •
Transmitir conteúdo ao vivo. Uma organização de notícias pode usar a Automation API para agendar a captura automática e transmissão de conteúdo ao vivo. Por exemplo, departamentos de transporte local podem transmitir imagens reais das condições de trânsito em vários pontos críticos, alertando os motoristas dos congestionamento de tráfego e os informando de rotas alternativas.
•
Conteúdo de processamento em lote. Uma organização de produção de mídia que deve processar um volume alto de arquivos grandes pode criar um processo em lotes que usa a Automation API repetidamente para capturar e codificar fluxos, um após o outro. Uma empresa pode usar a Automation API para gerenciar seus serviços de mídia de fluxo com uma linguagem de script preferencial e o Windows Script Host. Windows Script Host é um host independente de linguagem que pode ser usado para executar qualquer mecanismo de script no Microsoft Windows® 95 ou posterior, Windows NT, ou sistemas operacionais Windows 2000
•
Criar uma interface de usuário personalizada. Um provedor de serviço Internet (ISP) pode criar uma interface que usa a funcionalidade da Automation API para capturar, codificar, e transmitir fluxos de mídia. Como alternativa, você pode usar as interfaces de usuário predefinidas dentro da Automation API para a mesma finalidade.
•
Administrar aplicativos do Windows Media Encoder remotamente. Você pode usar a Automation API para executar, solucionar problemas, e administrar aplicativos do Windows Media Encoder em um computador remoto.
Para mais informações, consulte Windows Media Encoder 9 Series SDK no MSDN Online. O tópico Programação C# descreve quais referências incluir ao trabalhar em C#. O Windows Media Server O Microsoft® Windows Media® Services 9 Series Software Development Kit (SDK) é uma poderosa Application Programming Interface (API) baseada em automação projetada para qualquer pessoa que deseje desenvolver um aplicativo Windows Media Services 9 Series. Você pode usar este SDK no C# programaticamente para gerenciar um servidor do Windows Media para enviar conteúdo de mídia digital a clientes em redes que permitem unicast e multicast. Para mais informações, consulte Windows Media Services 9 Series SDK.
Visual C# Consolidado
153
CRIANDO STARTER KITS (VISUAL C#) Um Starter Kit contém código para um aplicativo completo e documentação sobre como modificar ou expandir o aplicativo. O Visual C# 2005 fornece dois Starter Kits que você pode acessar a partir da caixa de diálogo New Project. Você também pode criar seus próprios Starter Kits para ajudar os usuários obter e executar rapidamente em qualquer tipo de aplicativo. Criar um Starter Kit é fundamentalmente o mesmo que criar um modelo de projeto normal, a única diferença é que um Starter Kit contém arquivos de documentação que estão definidos para abrir um projeto com base no Starter Kit quando for criado. Para mais informações, consulte Introdução ao Starter Kits.
Visual C# Consolidado
154
MIGRANDO PARA O VISUAL C# Esta seção apresenta sintaxe C# e conceitos para desenvolvedores que estiver migrando de outras linguagens de programação. Ele também contém a documentação de referência do Java conversão Assistente, que você pode usar para converter origem linguagem Java em Código fonte C# idioma.
C# para desenvolvedores Java Os tópicos nesta seção fornecem uma introdução à linguagem C# e o .NET Framework. Nesta seção •
A linguagem de programação C# para desenvolvedores Java
•
Exemplos de código C# para desenvolvedores Java
•
Tipos de aplicativos C# para desenvolvedores Java
Convertendo aplicativos Java para Visual C# Fornece Microsoft Visual Studio 2005 a capacidade para converter projetos criados no Visual J ++ ®. ® versão 6.0 ou escrito em linguagem Java para Visual C# para que você pode tirar proveito do .NET Framework Java Language Conversion Assistente gera um novo Visual C# projeto de um J visual existente ++ 6.0 projeto ou idioma Java-arquivos. O assistente Java Language Conversion assistente torna fácil a converter os arquivos existentes.
Para desenvolvedores C++ C# A tabela a seguir contém importantes comparações entre C# e C++ nativo, que não usa /clr. Se você for um programador C++, esta tabela permitirá que você as diferenças entre duas linguagens de relance as mais importantes. Observação Projetos C# e C++ são derivados dos modelos de projetos diferentes. Para obter mais informações sobre as diferenças entre projetos C++ e C#, consulte Gerenciamento item no projetos e Usando Solution Explorer.
Recurso
Consulte o tópico
Herança: em C++, classes e estruturas são praticamente idênticas enquanto em C#, eles são bem diferentes. Classes C# pode implementar qualquer número de interfaces, mas pode herdar de apenas uma classe base. Além disso, estruturas C# não oferece suporte a herança, e não oferecerem suporte para construtores padrão explícito (um é fornecida por padrão).
Classe Interface struct (Referência do C#)
Matrizes: em C++ uma matriz é simplesmente um ponteiro. No C#, matrizes são objetos que incluem métodos e propriedades. Por exemplo, o tamanho de uma matriz pode ser consultado via a Length propriedade. Matrizes C# também empregar Indexadores que verificam cada índice usado para acessar a matriz. A sintaxe de declaração matrizes C# é diferente do idioma para matrizes C++: os símbolos [] " " aparecer após o tipo de matriz no C#, não a variável.
Matrizes (Guia de programação do C#) Indexadores (guia de programação C#)
Booleans: em C++, o bool tipo é essencialmente um inteiro. Em C#, há
bool
Visual C# Consolidado
155
nenhuma conversão entre o bool tipo e outros tipos. O long tipo enquanto em C++, ele está 32 bits.: em C#, o long tipo é 64 bits,
long
Passar parâmetros: em C++, todas as variáveis são passados por valor, a menos que explicitamente passados com um ponteiro ou uma referência. Do ref no C#, classes são passados por referência e estruturas são passadas pelo valor a menos que explicitamente passados por referência com ou out modificadores de parâmetro.
struct Classe (referência) C# ref Fora (referência C#)
A switch instrução: ao contrário a instrução C++ switch, C# não oferece suporte through fall-de um rótulo case para outro.
Alternar
Representantes: representantes C# são aproximadamente semelhantes aos indicadores de função em C++, são de tipo seguro e segura.
Delegar
Métodos de classe base: C# oferece suporte a base palavra-chave para chamar os membros de substituído classe base de classes derivadas. Além disso, substituir métodos virtual ou abstract é explícito em C#, usando a override palavra-chave.
Base Consulte também os exemplos para Substituir
Ocultando método: C++ oferece suporte a implícito " ocultar " do método através de herança. Em C#, você deve usar o new modificador para explicitamente ocultar um membros herdadas
Novo
Diretivas de pré-processamento são usadas para compilação condicional. Nenhum arquivo de cabeçalho são usados em C#.
Directives Preprocessor C#
A manipulação de exceção e exceção é acionada.: C# fornece palavrachave finally para fornecer para código que deve ser executado independentemente de se
finally tryfinally try-catch-
Operadores C# e typeof.: C# oferece suporte, como is operadores adicionais Ele também apresenta funcionalidade diferente para alguns operadores lógicos.
& Operator Operador | Operador ^ é TypeOf
Palavra-chave extern: em C++, extern é usado para importar tipos. No C#, extern é usada para criar aliases para usar versões diferentes do mesmo conjunto.
extern
Palavra-chave static: em C++, static pode ser usado tanto para declarar entidades nível de classe e para declarar tipos que são específicos para um módulo. No C#, static só é usada para declarar entidades nível de classe.
static
O Main método em C# é declarado de forma diferente da função main em C++. Em C#, ele seja maiúscula e sempre static. Além disso, o suporte para processamento de argumentos de linha de comando é muito mais robusta em C#.
Main() e argumentos de linha de comando (Guia de programação C#)
Ponteiros são permitidos em C#, mas somente no unsafe modo.
Não seguro
Sobrecarga operadores será executada de maneira diferente em C#.
Operadores C#
Seqüências: em C++ uma seqüência é simplesmente um arra de caracteres. Em C#, seqüências são objeto que oferecem suporte robustos métodos de pesquisa.
string String
Palavra-chave foreach permite-lhe percorrer matrizes e coleções.
foreach, em
Visual C# Consolidado
156
Globals: em C#, não há suporte para métodos globais e variáveis Métodos e variáveis precisa estar contidos em ou struct. um class
Estrutura geral de um programa C#
Importando Tipos: em C++, tipos comuns a vários módulos são colocados em arquivos de cabeçalho. No C#, essas informações está disponíveis através de metadados.
Usando Visão Geral Sobre Metadados
Variáveis locais em C# não podem ser usadas antes que eles sejam inicializados.
Métodos (Guia de programação do C#)
Gerenciamento de memória: C++ não é uma linguagem de lixo coletado; memória que é não explicitamente Release permanece alocada até que o processo termina. C# é uma linguagem de lixo coletado.
Coleta de Lixo
Destructors: C# tem sintaxe diferente para deterministically liberando recursos não gerenciados.
Destructors Instrução using (Referência do C#)
Construtores: similar ao C++, se você não fornecer um construtor de classe em C#, um construtor padrão é gerado automaticamente para você. O construtor padrão inicializa todos os campos para seus valores padrão.
Construtores da instância Tabela de valores padrão
C# não oferece suporte campos Bit.
Campos bit C++
Serviços de entrada / saída C# e formatação contam com a biblioteca de tempo de execução do .NET Framework.
Tour linguagem C# Formatação numérica tabela de resultados
Em C#, parâmetros de método não podem ter valores padrão. Use overloads método se você desejar obter o mesmo efeito.
Compilador CS0241 de erro
Em C#, tipos genéricos e métodos fornecem para parametrização Tipo de uma maneira que é semelhante aos modelos C++, embora existem diferenças significativas.
Generics em C#
Palavra-chave as é semelhante a um efeito padrão, exceto que em vez de acionar uma exceção se falhar a conversão, o valor de retorno é nulo. Isso é semelhante ao uso static_cast em C++, que,. diferente dynamic_cast, executa nenhuma verificação em tempo de execução e, portanto, não não acionar uma exceção na falha
Como referência (C#)
Para obter mais informações sobre comparações entre palavras-chave em C# e outras linguagens de programação, consulte Equivalentes do idioma. Para obter informações sobre a estrutura geral do aplicativos C#, consulte Estrutura geral de um programa C# (guia de programação C#).
Visual C# Consolidado
157
GUIA DE PROGRAMAÇÃO C# Esta seção fornece informações detalhadas sobre vários recursos chaves da linguagem C# acessíveis através do .NET Framework. Seções de idioma Em um programa C# Main() e argumentos de linha de comando (Guia de programação C#) Tipos de dados (guia de programação C#) Matrizes (Guia de programação do C#) Seqüências (guia de programação C#) Instruções, expressões, e operadores (guia de programação C#) Objetos, classes e Structs (guia de programação C#) Propriedades (Guia de programação do C#) Indexadores (guia de programação C#) Representantes (guia de programação C#) Eventos (Guia de programação do C#) Generics (Guia de programação C#) Iterators (guia de programação C#) Namespaces (Guia de programação C#) Tipos anuláveis (guia de programação C#) Não seguro código e ponteiros (guia de programação C#) Comentários de documentação XML (Guia de programação C#)
Em um programa C# A seção aborda a estrutura geral de um programa C#, e inclui o Exemplo padrão " Hello, World! ". Nesta seção •
Hello world--seu programa primeiro (guia de programação C#)
•
Estrutura geral de um programa C# (guia de programação C#) Seções relacionadas
•
Guia de Introdução ao Visual C#
•
Migrando para o Visual C#
•
Guia de Programação C#
•
Referência C#
•
Exemplos do Visual C# Especificação da Linguagem C#
Para obter mais informações, consulte as seções a seguir no Especificação da Linguagem C#: •
Introdução 1
Visual C# Consolidado
158
Hello world-seu primeiro programa (guia de programação C#) O seguinte programa Console é a versão do programa Tradicional do "Hello World!", que exibe a seqüência Hello World! C#. CSharp using System; // A "Hello World!" program in C# namespace HelloWorld { class Hello { static void Main() { System.Console.WriteLine("Hello World!"); } } } Vamos agora examinar as partes importantes deste programa por sua vez. Comentários A primeira linha contém um comentário: CSharp // A "Hello World!" program in C# Os caracteres // convertem o restante da linha em um comentário. Você também pode comentar um bloco de texto, colocando-o entre os caracteres /* e */, por exemplo: CSharp /* A "Hello World!" program in C#. This program displays the string "Hello World!" on the screen. */ O método principal O programa C# deve conter um método chamado Main, no qual o controle de execução inicia e termina. O método Main é onde você cria objetos e executa outros métodos. O método Main é um método static (estático) que reside em uma classe ou uma estrutura. No Exemplo anterior "Hello World! ", ele reside em uma classe chamada Hello. Declare o método Main de uma das maneiras a seguir: Podendo retornar void:
•
CSharp static void Main() { //... } Podendo também retornar um int:
•
CSharp static int Main() { //... return 0; } Com ambos os tipos de retorno, pode levar argumentos:
•
CSharp static void Main(string[] args) { //... } OuCSharp static int Main(string[] args) { //... return 0; } O parâmetro do método Main é uma matriz (array) de string que representa os argumentos de linha de comando usados para chamar o programa. Observe que, diferentemente C++, essa matriz não inclui o nome do arquivo executável (EXE). Para obter mais informações sobre como usar argumentos de linha de comando, consulte o Exemplo em Main() e argumentos de linha de comando (Guia de programação C#) e COMO: Criar e usar DLLs em C# (Guia de programação C#). Entrada e Saída
Visual C# Consolidado
159
Programas C# geralmente usam os serviços de entrada / saída fornecidos pela Biblioteca de tempo de execução do .NET Framework A instrução, System.Console.WriteLine("Hello World!"); usa o método WriteLine , um dos métodos de saída da classe Console na biblioteca de tempo de execução. Ele exibe seu parâmetro de seqüência no fluxo de saída padrão seguido por uma nova linha. Outros métodos da classe Console são usados para diversas operações de entrada e saída. Se você incluir a diretiva using System;no início do programa, você pode usar as classes e métodos do namespace System sem ter de referenciá-los totalmente. Por exemplo, você pode chamar Console.WriteLine Em vez de, System.Console.Writeline: CSharp using System; CSharp Console.WriteLine("Hello World!"); Para obter mais informações sobre métodos de entrada / saída, consulte System.IO. Compilação e execução Você pode compilar o programa " Hello World! " Criando um projeto no Visual Studio IDE, ou usando a linha de comando. Use o Prompt de Comandos do Visual Studio ou execute o arquivo vsvars32.bat para colocar a ferramenta Visual C# definida no caminho do seu prompt de comando. Para compilar o programa a partir da linha de comando: •
Crie o arquivo de origem usando qualquer editor de texto e salvá-lo usando um nome, como Hello.cs. Arquivos código fonte C# usam a extensão .cs. Para chamar o compilador, digite o comando:
•
csc Hello.cs Se seu programa não contém quaisquer erros de compilação, um arquivo chamado Hello.exe será criado. •
Para executar o programa, digite o comando:
Hello Para obter mais informações sobre o compilador C# e suas opções, consulte Opções do compilador C#.
Estrutura geral de um programa C# (guia de programação C#) Programas C# podem consistir de um ou mais arquivos. Cada arquivo pode não conter espaços para nome (namespaces), ou conter vários. Espaços para nome podem conter tipos, como classes, estruturas, interfaces, enumerações, e representantes (delegates), além de outros espaços. A seguir temos o esqueleto de um programa C# que contém todos esses elementos. CSharp // A skeleton of a C# program using System; namespace YourNamespace { class YourClass { } struct YourStruct { } interface IYourInterface { } delegate int YourDelegate(); enum YourEnum { } namespace YourNestedNamespace { struct YourStruct { } } class YourMainClass { static void Main(string[] args) { //Your program starts here... } } }
Main() e argumentos de linha de comando (Guia de programação C#) O método Main é o ponto de entrada do seu programa, onde você cria objetos e chama outros métodos. Só pode haver um único ponto de entrada em um programa C#.
Visual C# Consolidado
160
CSharp class TestClass { static void Main(string[] args) { // Display the number of command line arguments: System.Console.WriteLine(args.Length); } } Visão Geral •
O Main método é o ponto de entrada do seu programa, onde o controle de execução do programa inicia e termina.
Ele é declarado dentro de uma classe ou estrutura. Ele deve ser estático (static) e ele não deve ser público. (No Exemplo acima, como não especificamos um modificador de acesso explicitamente, ele recebe o modificador de acesso padrão, que é (private) particular). •
Ou ele pode retornar void ou então um tipo int.
•
O método Main pode ser declarado com ou sem parâmetros.
•
Parâmetros podem ser lidos como argumentos de linha de comando indexados a partir do zero.
•
Diferentemente C e C++, o nome do programa não é tratado como o primeiro argumento de linha de comando.
Argumentos de linha de comando (guia de programação C#) O Main método pode usar argumentos, nesse caso, é necessário uma das seguintes formas: C# static int Main(string[] args) C# static void Main(string[] args) O parâmetro do método Main é uma String matriz que representa os argumentos de linha de comando. Geralmente você verificar a existência dos argumentos testando a Length propriedade, por exemplo: C# if (args.Length == 0) { System.Console.WriteLine("Please enter a numeric argument."); return 1; } Você também pode converter os argumentos de seqüência para tipos numéricos, usando a Convert classe ou o Parse método. Por exemplo, a instrução a seguir converte a seqüência em um número longo, usando o Parse método na classe Int64: long num = Int64.Parse(args[0]); Também é possível para usar o tipo long C#, os aliases Int64: long num = long.Parse(args[0]); Você pode usar o Convert método ToInt64 de classe para fazer a mesma coisa: long num = Convert.ToInt64(s); Para obter mais informações, consulte Parse e Convert. Exemplo Neste exemplo, o programa leva um argumento em tempo de execução, converte o argumento em um inteiro, e calcula o fatorial do número. Se nenhum argumento são fornecidos, o programa emite uma mensagem que explica o uso correto do programa. C# // arguments: 3
Visual C# Consolidado
161
C# public class Functions { public static long Factorial(int n) { if (n < 0) { return -1; } //error result - undefined if (n > 256) { return -2; } //error result - input is too big if (n == 0) { return 1; } // Calculate the factorial iteratively rather than recursively: long tempResult = 1; for (int i = 1; i <= n; i++) { tempResult *= i; } return tempResult; } } C# class MainClass { static int Main(string[] args) { // Test if input arguments were supplied: if (args.Length == 0) { System.Console.WriteLine("Please enter a numeric argument."); System.Console.WriteLine("Usage: Factorial "); return 1; } try { // Convert the input arguments to numbers: int num = int.Parse(args[0]); System.Console.WriteLine("The Factorial of {0} is {1}.", num, Functions.Factorial(num)); return 0; } catch (System.FormatException) { System.Console.WriteLine("Please enter a numeric argument."); System.Console.WriteLine("Usage: Factorial "); return 1; } } } Saída The Factorial of 3 is 6. Comentários A seguir estão dois executa de Exemplo de programa assumindo o que é Factorial.exe o nome do programa.
Execute # 1: Insira a seguinte linha de comando: Factorial 10 Você obtém o seguinte resultado: The Factorial of 10 is 3628800.
Execute # 2: Insira a seguinte linha de comando: Factorial Você obtém o seguinte resultado: Please enter a numeric argument. Usage: Factorial
COMO: Exibir argumentos de linha de comando (Guia de programação C#) Argumentos fornecidos para um executável na linha de comando são acessíveis através um parâmetro opcional para Main. Os argumentos são fornecidos na forma de uma matriz de seqüências. Cada elemento da matriz contém um argumento. Espaço White-entre argumentos é removido. Por exemplo, considere essas invocações de linha de comando de um executável fictícia: Entrada na linha de comando
Matriz de seqüências de caracteres passado para principal
executable.exe a b c
"a" "b" "c"
executable.exe one two
" um " " dois "
executable.exe “one two” three " dois " um
Visual C# Consolidado
162
" três " Exemplo Este Exemplo exibe os argumentos de linha de comando passados para um aplicativo de linha de comando. O resultado mostrado é para a primeira entrada na tabela acima. C# class CommandLine { static void Main(string[] args) { // The Length property provides the number of array elements System.Console.WriteLine("parameter count = {0}", args.Length); for (int i = 0; i < args.Length; i++) { System.Console.WriteLine("Arg[{0}] = [{1}]", i, args[i]); } } }
COMO: Acessar argumentos de linha de comando usando foreach (Guia de programação C#) Outra abordagem para Iterando através da matriz é a usar a foreach instrução conforme mostrado no exemplo. A foreach instrução pode ser usada para iterar por uma matriz, uma classe Coleção .NET Framework, ou qualquer classe ou estrutura que implementa a IEnumerable interface. Exemplo Este Exemplo demonstra como imprimi-los os argumentos de linha de comando usando foreach. C# // arguments: John Paul Mary C# class CommandLine2 { static void Main(string[] args) { System.Console.WriteLine("Number of command line parameters = {0}", args.Length); foreach (string s in args) { System.Console.WriteLine(s); } } }
Saída Number of command line parameters = 3 John Paul Mary
Main() retorna valores (Guia de programação C#) O Main método pode ser do tipo void: C# static void Main() { //... } Ele também pode retornar um int: C# static int Main() { //... return 0; } Se o valor de retorno da Main não deve ser usado, seguida, retornar void permite que código ligeiramente mais simples. No entanto, retornar um inteiro permite que o programa para relacionar informações de status para outros programas ou scripts que chamar o executável. Um Exemplo de usar o valor de retorno da Main é mostrado no Exemplo a seguir. Exemplo Um arquivo em lotes, neste Exemplo é usado para executar um programa e testar o valor a Main função de retorno. Quando um programa é executado no Windows, qualquer valor retornado da Main função é armazenado em uma variável de ambiente chamada ERRORLEVEL. Ao inspecionar a
Visual C# Consolidado
163
variável, arquivos em lotes portanto podem determinar o resultado da execução. Tradicionalmente, um valor de retorno de zero indica execução com êxito. Abaixo é um programa muito simples que retorna zero da função Main.
ERRORLEVEL
C# class MainReturnValTest { static int Main() { //... return 0; } } Como este Exemplo usa um arquivo em lotes, é melhor para compilar esse código a partir da linha de comando, conforme demonstrado no Como construir a partir da linha de comando:. Em seguida, um arquivo em lotes é usado para chamar o executável resultante do Exemplo de código anterior. Porque o código retorna zero, o arquivo em lotes irá reportar êxito, mas se o código anterior é alterado para retornar um valor diferente de zero, e é então re-Compiled, subseqüente execução do arquivo em lotes indicará falha. rem test.bat @echo off MainReturnValueTest @if "%ERRORLEVEL%" == "0" goto good :fail echo Execution Failed echo return value = %ERRORLEVEL% goto end :good echo Execution Succeded echo return value = %ERRORLEVEL% goto end :end Saída de exemplo Execution Succeded return value = 0
Tipos de dados (guia de programação C#) C# é uma linguagem altamente digitada; portanto cada variável e objeto deve ter um tipo declarado. Visão geral sobre tipos de dados Um tipo de dados pode ser descrito como sendo um: •
Um tipo, como dados internos ou char, ou um int
•
Um tipo, como dados definidos pelo usuário ou interface. um class
•
Tipos de dados também podem ser definidos como sendo um:
•
Tipos valor (referência C#) que armazenam valores, ou
•
Tipos de referência (referência C#) que armazenam referências para os dados reais. Seções relacionadas
Para obter mais informações: •
Projetando (guia de programação C#)
•
Boxing e Unboxing (C# programação guia)
•
Tipos (referência C#)
•
Objetos, classes e Structs (guia de programação C#) Especificação da Linguagem C#
Para obter mais informações sobre tipos, consulte as seções a seguir no Especificação da Linguagem C#: •
Tipos 1.3 e variáveis
•
Namespace 3.8 e nomes tipo
•
Tipos valor 4.1
•
Tipos de referência 4.2
•
4.3 Boxing e Unboxing
Visual C# Consolidado
164
MATRIZES (GUIA DE PROGRAMAÇÃO DO C#) Uma matriz é uma estrutura de dados que contém um número de variáveis do mesmo tipo. Matrizes são declaradas com um tipo: type[] arrayName; Os exemplos a seguir criar matrizes dimensional única, multidimensional, e denteadas: C# class TestArraysClass { static void Main() { // Declare a single-dimensional array int[] array1 = new int[5]; // Declare and set array element values int[] array2 = new int[] { 1, 3, 5, 7, 9 }; // Alternative syntax int[] array3 = { 1, 2, 3, 4, 5, 6 }; // Declare a two dimensional array int[,] multiDimensionalArray1 = new int[2, 3]; // Declare and set array element values int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } }; // Declare a jagged array int[][] jaggedArray = new int[6][]; // Set the values of the first array in the jagged array structure jaggedArray[0] = new int[4] { 1, 2, 3, 4 }; } } Visão geral de matriz Uma matriz tem as seguintes propriedades: •
Pode ser Dimensional único uma matriz, Multidimensional ou Jagged.
•
O valor padrão de elementos da matriz numérica são definidas como zero, e elementos de referência são definidos como nulo.
•
Uma matriz denteada é uma matriz de matrizes, e portanto seus elementos são tipos de referência e são inicializados para null.
•
Matrizes forem zero indexado: uma matriz com n elementos é indexada a partir 0 para n-1.
•
Elementos de matriz podem ser de qualquer tipo, incluindo um tipo de matriz.
•
Tipos de matriz são Tipos de referência derivados do tipo Array base abstrato. Desde isso e IEnumerable implementa IEnumerable Tipo, você pode utilizar foreach iteração em todas as matrizes em C#.
Matrizes como objetos (guia de programação C#) No C#, matrizes são realmente objetos, e não apenas endereçáveis regiões de memória contígua como em C e C++. é Array o tipo base abstrato de todos os tipos de matriz. Você pode usar as propriedades, e outros membros da classe, que Array tem. Um Exemplo disso deve estar usando a Length propriedade para obter o comprimento de uma matriz. O código a seguir atribui o comprimento da matriz numbers, que é 5, a uma variável chamada lengthOfNumbers: C# int[] numbers = { 1, 2, 3, 4, 5 }; int lengthOfNumbers = numbers.Length; A System.Array classe fornece vários outros útil métodos e propriedades para classificação, pesquisa, e copiando matrizes. Exemplo Este Exemplo usa a Rank propriedade para exibir o número de dimensões de uma matriz. C# class TestArraysClass { static void Main() { // Declare and initialize an array: int[,] theArray = new int[5, 10]; System.Console.WriteLine("The array has {0} dimensions.", theArray.Rank); } }
Visual C# Consolidado
165
Saída The array has 2 dimensions.
Matrizes multidimensionais (guia de programação C#) Matrizes podem ter mais de uma dimensão. Por exemplo, a declaração a seguir cria uma matriz bidimensional de quatro linhas e duas colunas: C# int[,] array = new int[4, 2]; Além disso, a declaração a seguir cria uma matriz de três dimensões, 4, 2 e 3: C# int[, ,] array1 = new int[4, 2, 3]; Inicialização de matriz Você pode inicializar a matriz na declaração conforme mostrado no Exemplo o seguir: C# int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }; int[, ,] array3D = new int[,,] { { { 1, 2, 3 } }, { { 4, 5, 6 } } }; Você também pode inicializar a matriz sem especificar a classificação: C# int[,] array4 = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }; Se você optar por declarar uma variável de matriz sem a inicialização, você deve usar o new operador para atribuir uma matriz à variável Por exemplo: C# int[,] array5; array5 = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }; // OK //array5 = {{1,2}, {3,4}, {5,6}, {7,8}}; // Error Você também pode atribuir um valor a um elemento de matriz, por exemplo: C# array5[2, 1] = 25; O Exemplo de código a seguir inicializa as variáveis de matriz como padrão (exceto para denteadas matrizes): C# int[,] array6 = new int[10, 10];
Matrizes passagem como parâmetros (guia de programação C#) Matrizes podem ser passados para métodos como parâmetros. Como matrizes são tipos de referência, o método pode alterar o valor dos elementos. Passando matrizes dimensional única como parâmetros Você pode passar uma matriz dimensional única inicializado para um método. Por exemplo: C# PrintArray(theArray); O método chamado na linha acima poderia ser definido como: C# void PrintArray(int[] arr) { // method code }
Visual C# Consolidado
166
Você também pode inicializar e passa uma nova matriz em uma etapa Por exemplo: C# PrintArray(new int[] { 1, 3, 5, 7, 9 }); Exemplo 1
Descrição No Exemplo a seguir, a uma matriz de seqüência de caracteres é inicializado e passado como um parâmetro para o PrintArray método, onde seus elementos são exibidos:
Código C# class ArrayClass { static void PrintArray(string[] arr) { for (int i = 0; i < arr.Length; i++) { System.Console.Write(arr[i] + "{0}", i < arr.Length - 1 ? " " : ""); } System.Console.WriteLine(); } static void Main() { // Declare and initialize an array: string[] weekDays = new string[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; // Pass the array as a parameter: PrintArray(weekDays); } } Saída 1 Sun Mon Tue Wed Thu Fri Sat Passando Matrizes multidimensionais como parâmetros Você pode passar uma matriz multidimensional inicializado para um método. Por exemplo, matriz dimensional for theArray Um dois: C# PrintArray(theArray); O método chamado na linha acima poderia ser definido como: C# void PrintArray(int[,] arr) { // method code } Você também pode inicializar e passa uma nova matriz em uma etapa Por exemplo: C# PrintArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }); Exemplo 2
Descrição Neste exemplo, uma matriz bidimensional é inicializado e passada para o PrintArray método, onde seus elementos são exibidos.
Código C# class ArrayClass2D { static void PrintArray(int[,] arr) { // Display the array elements: for (int i = 0; i < 4; i++) { for (int j = 0; j < 2; j++) { System.Console.WriteLine("Element({0},{1})={2}", i, j, arr[i, j]); } } } static void Main() { // Pass the array as a parameter: PrintArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }); } } Saída 2 Element(0,0)=1 Element(0,1)=2 Element(1,0)=3 Element(1,1)=4 Element(2,0)=5
Visual C# Consolidado
167
Element(2,1)=6 Element(3,0)=7 Element(3,1)=8
Passando REF usando matrizes e out (guia programação C#) Todos os Limite parâmetros, como um out parâmetro de um tipo de matriz deve ser atribuído antes que ela é usada; ou seja, ele deve ser atribuído pelo chamado. Por exemplo: C# static void TestMethod1(out int[] arr) { arr = new int[10]; // definite assignment of arr } Como todos os Ref parâmetros, um ref parâmetro de um tipo de matriz deve ser atribuído pelo chamador definitivamente. Portanto, não é necessário para serem atribuídos pelo chamado definitivamente. Um ref parâmetro de um tipo de matriz pode ser alterado como resultado da chamada. Por exemplo, a matriz pode ser atribuído o Nulo valor ou podem ser inicializados para uma matriz diferente. Por exemplo: C# static void TestMethod2(ref int[] arr) { arr = new int[10]; // arr initialized to a different array } Os seguintes exemplos dois demonstram a diferença entre out e ref quando usada em passar matrizes para métodos. Exemplo 1 Neste exemplo, a matriz theArray é declarado no chamador (o Main método), e inicializado no método FillArray. Em seguida, os elementos da matriz são retornados para o chamador e exibido. C# class TestOut { static void FillArray(out int[] arr) { // Initialize the array: arr = new int[5] { 1, 2, 3, 4, 5 }; } static void Main() { int[] theArray; // Initialization is not required // Pass the array to the callee using out: FillArray(out theArray); // Display the array elements: System.Console.WriteLine("Array elements are:"); for (int i = 0; i < theArray.Length; i++) { System.Console.Write(theArray[i] + " "); } } } Saída 1
Array elements are: 12345 Exemplo 2 Neste exemplo, a matriz theArray é inicializado no chamador (o Main método), e passada para o FillArray método usando o ref parâmetro. Algumas dos elementos da matriz são atualizadas no método FillArray. Em seguida, os elementos da matriz são retornados para o chamador e exibido. C# class TestRef { static void FillArray(ref int[] arr) { // Create the array on demand: if (arr == null) { arr = new int[10]; } // Fill the array: arr[0] = 1111; arr[4] = 5555; } static void Main() { // Initialize the array: int[] theArray = { 1, 2, 3, 4, 5 }; // Pass the array using ref: FillArray(ref theArray); // Display the updated array: System.Console.WriteLine("Array elements are:"); for (int i = 0; i < theArray.Length; i++) { System.Console.Write(theArray[i] + " "); } } } Saída 2 Array elements are: 1111 2 3 4 5555
Visual C# Consolidado
168
Exemplo matrizes Download sample Este Exemplo descreve e mostra como matrizes funcionam em C#. Para obter mais informações, consulte Matrizes (Guia de programação do C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo matrizes no Visual Studio •
No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo matrizes a partir da linha de comando •
Digite o seguinte no prompt de comando: csc arrays.cs arrays
Seqüências (guia de programação C#) As seções a seguir discutem o string tipo de dados, que é um alias para a String classe.
Usando Strings (guia de programação C#) Uma seqüência C# é uma matriz de caracteres declarado usando a string palavra-chave. Uma seqüência de caracteres literal é declarada usar aspas, como mostrado no Exemplo a seguir: C# string s = "Hello, World!"; Você pode extrair substrings, e concatenar seqüências, como este: C#
Visual C# Consolidado
169
string s1 = "orange"; string s2 = "red"; s1 += s2; System.Console.WriteLine(s1); // outputs "orangered" s1 = s1.Substring(2, 5); System.Console.WriteLine(s1); // outputs "anger" Objetos seqüência são imutável, significando que eles não podem ser alterados uma vez que tenha sido criada. Métodos que atuam em seqüências realmente retornam novos objetos de seqüência. No Exemplo anterior, quando o conteúdo de s1 e s2 são concatenadas para formar uma única seqüência, as duas seqüências contendo "orange" e "red" são mantidos inalterados ambos. O += operador cria uma nova seqüência contendo o conteúdo combinados. O resultado é que s1 se refere a uma seqüência diferente totalmente agora. Uma seqüência contendo apenas "orange" ainda existe, mas não é referenciado quando s1 é concatenada. Portanto, por razões de desempenho, grandes quantidades de concatenação ou outra manipulação de seqüência de caracteres envolvidos devem ser executadas com a StringBuilder classe, como este: C# System.Text.StringBuilder sb = new System.Text.StringBuilder(); sb.Append("one "); sb.Append("two "); sb.Append("three"); string str = sb.ToString(); A StringBuilder classe é discutida mais na seção " StringBuilder usando ". Trabalhando com seqüências
Escape caracteres Escape caracteres, como " \n " (nova linha) e " \t " (guia) pode ser incluídas em seqüências. A linha: C# string hello = "Hello\nWorld!"; é o mesmo que: Hello World! Se você desejar incluir uma barra com versões anteriores, ele deve ser precedido com outro invertida. A seqüência a seguir: C# string filePath = "\\\\My Documents\\"; é realmente o mesmo que: \\My Documents\
O símbolo @ O @ Símbolo informa o Construtor de seqüência para ignorar caracteres de escape e quebras de linha. As seguintes seqüências duas são portanto idênticas: C# string p1 = "\\\\My Documents\\My Files\\"; string p2 = @"\\My Documents\My Files\";
ToString() Como todos os objetos derivados Object, seqüências fornecem o ToString método, que converte um valor em uma seqüência. Este método pode ser usado para converter valores numéricos em seqüências, como este: C# int year = 1999; string msg = "Eve was born in " + year.ToString(); System.Console.WriteLine(msg); // outputs "Eve was born in 1999"
Visual C# Consolidado
170
Acessando caracteres individuais Caracteres individuais contidos em uma seqüência de caracteres podem ser acessados usando métodos, como SubString(), Replace(), Split() e Trim(). C# string s3 = "Visual C# Express"; System.Console.WriteLine(s3.Substring(7, 2)); // outputs "C#" System.Console.WriteLine(s3.Replace("C#", "Basic")); // outputs "Visual Basic Express" Também é possível para copiar os caracteres em uma matriz de caracteres, como este: C# string s4 = "Hello, World"; char[] arr = s4.ToCharArray(0, s4.Length); foreach (char c in arr) { System.Console.Write(c); // outputs "Hello, World" } Caracteres individuais de uma seqüência podem ser acessados com um índice, como este: C# string s5 = "Printing backwards"; for (int i = 0; i < s5.Length; i++) { System.Console.Write(s5[s5.Length - i - 1]); // outputs "sdrawkcab gnitnirP" }
Alterando a Caixa Para alterar as letras em uma seqüência para superior ou minúsculas, use ToUpper() ou ToLower(), como isso: C# string s6 = "Battle of Hastings, 1066"; System.Console.WriteLine(s6.ToUpper()); // outputs "BATTLE OF HASTINGS 1066" System.Console.WriteLine(s6.ToLower()); // outputs "battle of hastings 1066"
Comparações Do == a maneira mais simples para comparar duas seqüências é para usar e != operadores, que executar uma comparação que diferencie maiúsculas de minúsculas. C# string color1 = "red"; string color2 = "green"; string color3 = "red"; if (color1 == color3) { System.Console.WriteLine("Equal"); } if (color1 != color2) { System.Console.WriteLine("Not equal"); } Objetos seqüência também ter um CompareTo() método que retorna um valor inteiro com base em se uma seqüência é menos-(<)or greater-than (>) que outra . Ao comparar seqüências, o valor Unicode é usado, e minúsculo tem um valor menor que maiúsculo. C# string s7 = "ABC"; string s8 = "abc"; if (s7.CompareTo(s8) > 0) { System.Console.WriteLine("Greater-than"); } else { System.Console.WriteLine("Less-than"); } Para procurar por uma seqüência dentro outra seqüência, use IndexOf(). Retorna IndexOf()-1 se a seqüência de pesquisa não encontrada; caso contrário, ele retorna o índice do primeiro local em que ele ocorre baseada em zero. C# string s9 = "Battle of Hastings, 1066"; System.Console.WriteLine(s9.IndexOf("Hastings")); // outputs 10 System.Console.WriteLine(s9.IndexOf("1967")); // outputs -1
Dividindo um string em Substrings Dividir uma seqüência em substrings —, como dividindo uma frase em palavras — individuais é uma tarefa de programação comuns. O Split() método utiliza uma char matriz de delimitadores,
Visual C# Consolidado
171
por exemplo, um caractere de espaço, e retorna uma matriz de substrings. Você pode acessar essa matriz com foreach, como este: C# char[] delimit = new char[] { ' ' }; string s10 = "The cat sat on the mat."; foreach (string substr in s10.Split(delimit)) { System.Console.WriteLine(substr); } Esse código saídas cada palavra em uma linha separada, como este: The cat sat on the mat. Usando StringBuilder A StringBuilder classe cria um buffer de seqüência que oferece melhor desempenho se seu programa executa uma grande quantidade de manipulação de seqüência de caracteres. A StringBuilder seqüência também permite que você para reatribuir caracteres individuais, algo que o tipo de dados de seqüência interna não oferece suporte. Esse código, por exemplo, altera o conteúdo de uma seqüência sem criar uma nova seqüência: C# System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet"); sb[0] = 'C'; System.Console.WriteLine(sb.ToString()); System.Console.ReadLine(); Neste exemplo, um StringBuilder objeto é usado para criar uma seqüência de um conjunto de tipos numéricos: C# class TestStringBuilder { static void Main() { System.Text.StringBuilder sb = new System.Text.StringBuilder(); // Create a string composed of numbers 0 - 9 for (int i = 0; i < 10; i++) { sb.Append(i.ToString()); } System.Console.WriteLine(sb); // displays 0123456789 // Copy one character of the string (not possible with a System.String) sb[0] = sb[9]; System.Console.WriteLine(sb); // displays 9123456789 } }
Visual C# Consolidado
172
ESPECIFICAÇÃO DA LINGUAGEM C# As versões 1.2 e 2.0 das especificações da linguagem C# são a fonte autorizada de gramática e sintaxe C#. Elas contêm informações detalhadas sobre todos os aspectos da linguagem, incluindo muitos pontos não abordados na documentação do produto Visual C#. A especificação 1.2 discute recursos que foram adicionados para a linguagem antes do Visual C# 2005 e a especificação 2.0 discute recursos que foram adicionados para o Visual C# 2005. As especificações da linguagem C# estão disponíveis no formato Microsoft Word nos seguintes locais: •
No MSDN Online em http://msdn.microsoft.com/vcsharp/Programming/Language/default.aspx
•
No Visual Studio, na pasta VC#\Specifications\1033\ sob o diretório de instalação do seu Microsoft Visual Studio 2005 . Se você não tiver o Microsoft Word instalado em seu computador, você pode visualizar, copiar e imprimir a versão do Word da especificação com o gratuito Palavra visualizador 2003. A especificação da linguagem C# também está disponível como um livro publicado pelo Addison Wesley.
Visual C# Consolidado
173
REFERÊNCIA C# Esta seção fornece material de referência para as palavras-chave do C#, operadores, erros de compilador e avisos.
Palavras-chave C# Palavras-chave são identificadores reservados que têm significado especial para o compilador. Eles não podem ser usados como identificadores em seu programa a menos que incluam @ como um prefixo. Por exemplo, @if é um identificador válido mas if não, porque é uma palavra-chave. abstract
event
new
struct
as
explicit
null
switch
base
extern
object
this
bool
false
operator
throw
break
finally
out
true
byte
fixed
override
try
case
foat
params
typeof
catch
for
private
uint
char
foreach
protected
uong
checked
goto
public
unchecked
class
if
readonly
unsafe
const
implicit
ref
ushort
continue
in
return
using
decimal
int
sbyte
virtual
default
interface
sealed
volatile
delegate
internal
short
void
do
is
sizeof
while
double
ock
stackaloc
else
ong
static
enum
namespace string
Palavras-chave contextuais Obter
parcial
Definir
Valor
Onde
Produzir
Palavra-chave abstract O modificador abstract pode utilizar com classes, métodos, propriedades, indicadores e eventos.
Visual C# Consolidado
174
Utilize o modificador abstract em uma declaração de classe se deseja indicar que a classe só deve atuar como classe-base de outras classes. As classes do tipo abstract apresentam as seguintes características: •
Não podem se criar instancias de uma classe abstrata.
•
Uma classe abstrata pode conter descritores de acesso e métodos abstratos.
•
Não é possível modificar uma classe abstrata com o modificador sealed, o qual significa que a classe não pode heredar. • Uma classe não abstrata derivada de uma classe abstrata deve incluir implementações reales de todos os descritores de acesso e métodos abstratos herdados. Utilize o modificador abstract em uma declaração de método ou propriedade para indicar que o método ou a propriedade não contém implementação. Os métodos abstratos apresentam as seguintes características:
•
Um método abstrato é, implícitamente, um método virtual.
•
As declarações de métodos abstratos só é permitido em classes abstratas.
• Como uma declaração de método abstrato não proporciona uma implementação, não existe corpo do método; a declaração de método finaliza simplemente com um ponto e vírgua e sem chaves ({ }) depois da firma. Por exemplo: public abstract void MyMethod(); • A implementação a proporciona um método de reemplazo, o qual é um membro de uma classe não abstrata.
Utilizar os modificadores static ou virtual em uma declaração de método abstrato produza um erro.
•
As propriedades abstratas funcionam como os métodos abstratos, salvo as diferenças na sintaxis das declarações e chamadas. •
É incorreto utilizar o modificador abstract em uma propriedade estática.
•
Uma propriedade abstrata herdada pode substituir em uma classe derivada se se inclui uma declaração de propriedade que use o modificador override. Uma classe abstrata deve proporcionar implementações para todos os membros da interface. Uma classe abstrata que implementa uma interface poderia assinalar os métodos da interface os métodos abstratos. Por exemplo:
interface I { void M(); } abstract class C: I { public abstract void M(); } Exemplo Neste exemplo, a classe MyDerivedC é derivada de uma classe abstrata MyBaseC. A classe abstrata contém um método abstrato, MyMethod(), e duas propriedades abstratas, GetX() e GetY(). // abstract_keyword.cs // Abstract Classes
Visual C# Consolidado
175
using System; abstract class MyBaseC // Abstract class { protected int x = 100; protected int e = 150; public abstract void MyMethod(); // Abstract method public abstract int GetX // Abstract property { get; } public abstract int GetY // Abstract property { get; } } class MyDerivedC: MyBaseC { public override void MyMethod() { x++; y++; } public override int GetX // overriding property { get { return x+10; } } public override int GetY // overriding property { get { return y+10; } } public static void Main() { MyDerivedC mC = new MyDerivedC(); mC.MyMethod(); Console.WriteLine("x = {0}, e = {1}", mC.GetX, mC.GetY); } }
Resultado x = 111, e = 161 No Exemplo anterior, se intenta criar uma instancia da classe abstrata mediante uma instrução como a seguinte: MyBaseC mC1 = new MyBaseC(); // Erro obterá a seguinte mensagem de erro:
Visual C# Consolidado
176
Cannot criate an instance of the abstract class 'MyBaseC'.
Palavra-chave event Especifica um evento. [attributes] [modifiers] e v e n t type declarator; [attributes] [modifiers] e v e n t type member-name { accessor-declarations} ; de onde: attributes (opcional) modifiers (opcional) •
Modificadores opcionais, entre os que se incluem:
•
abstract
•
new
•
override
•
static
•
virtual
•
extern
•
um dos quatro modificadores de acesso
type Tipo delegado ao qual se deseja associar este evento. declarator •
Mome do evento.
member-name •
Mome do evento.
accessor-declarations (opcional) Declaração de os descritores de acesso , os quais se utilizam para agregar ou quitar controladores de eventos no código cliente. As funções para descritores de acesso são add e remove. Definir só uma de elas produza um erro. Comentarios A palavra-chave event permite especificar um delegado ao qual se invocará quando ocorra algum "evento" no código. o delegado pode ter ou não o varios métodos asociados a os que se chamará quando o código indique que o evento se ha producido. É possível poner um evento de qualquer programa a disposição de outros programas que utilizem Common Language Runtime do .NET Framework. Para criar e utilizar eventos do C#, siga os seguintes pasos: Crie ou identifique um delegado. Se está definindo um evento propio, também deve asegurarse de que existe um delegado que possa utilizar com a palavra-chave event. Se o evento está predefinido, por Exemplo em .NET Framework, entonces os consumidores do evento só necessitan conhecer o nome do delegado. 1.
Crie uma classe que contenha: a. Um evento criado desde o delegado. b. Um método que comprova se existe uma instancia do delegado declarado com a palavra-chave event (este método é opcional). outra opção consiste em inserir este fragmento de código dentro do código que produza o evento.
Visual C# Consolidado
177
c. Os métodos que chaman ao evento. Estes métodos podem ser reemplazos de cierta funcionalidad da classe-base. Esta classe define ou evento. 2. Defina ao menos uma classe que conecte os métodos com o evento. Cada uma de estas classes incluirá o seguinte: •
A asociação de unão ou varios métodos, mediante os operadores += e -=, com o evento na classe-base.
•
A definição de os métodos que se asociarão com o evento.
3. •
Utilize ou evento: Crie um objeto da classe que contém a declaração do evento.
•
Crie um objeto da classe que contém a definição do evento, mediante ou construtor que definiu.
Resultado Exemplo 1 Este Exemplo mostra que é possível declarar um evento em uma interface e implementá-lo em uma classe: // event_keyword.cs using System; public delegate void MyDelegate(); // delegate declaration public interface I { event MyDelegate MyEvent; void FireAway(); } public class MyClass: I { public event MyDelegate MyEvent; public void FireAway() { if (MyEvent != null) MyEvent(); } } public class MainClass { static private void f() { Console.WriteLine("This is called whem the event fires."); } static public void Main () { I i = new MyClass(); i.MyEvent += new MyDelegate(f); i.FireAway();
Visual C# Consolidado
178
} } Exemplo 2 Unão de os usos daccessor-declarations consiste em exponer um gram número de eventos sem ter que assinalar um campo para cada evento, sinão utilizando em seu lugar uma taba hash que almacene as instancias de os eventos. Isto só resulta útil se se dispõe de um gram número de eventos, pois se preves que a maioría de os eventos não se implementarão. // event_keyword2.cs using System; using System.Collections; public delegate void MyDelegate1(int i); public delegate void MyDelegate2(string s); public delegate void MyDelegate3(int i, object o); public delegate void MyDelegate4(); public class PropertyEventsSample { private Hashtable eventTable = new Hashtable(); public event MyDelegate1 Event1 { add { eventTable["Event1"] = (MyDelegate1)eventTable["Event1"] + value; } remove { eventTable["Event1"] = (MyDelegate1)eventTable["Event1"] - value; } } public event MyDelegate1 Event2 { add { eventTable["Event2"] = (MyDelegate1)eventTable["Event2"] + value; } remove { eventTable["Event2"] = (MyDelegate1)eventTable["Event2"] - value; } } public event MyDelegate2 Event3 { add { eventTable["Event3"] = (MyDelegate2)eventTable["Event3"] + value; } remove { eventTable["Event3"] = (MyDelegate2)eventTable["Event3"] - value; }
Visual C# Consolidado
179
} public event MyDelegate3 Event4 { add { eventTable["Event4"] = (MyDelegate3)eventTable["Event4"] + value; } remove { eventTable["Event4"] = (MyDelegate3)eventTable["Event4"] - value; } } public event MyDelegate3 Event5 { add { eventTable["Event5"] = (MyDelegate3)eventTable["Event5"] + value; } remove { eventTable["Event5"] = (MyDelegate3)eventTable["Event5"] - value; } } public event MyDelegate4 Event6 { add { eventTable["Event6"] = (MyDelegate4)eventTable["Event6"] + value; } remove { eventTable["Event6"] = (MyDelegate4)eventTable["Event6"] - value; } } } public class MyClass { public static void Main() { } } Exemplo 3 Outro uso das propriedades de eventos contempla o caso no que se implementam duas interfaces, cada uma com um evento do mesmo nome. Nesse caso, deve utilizar uma propriedade de evento de implementação explícita: // event_keyword3.cs using System; public delegate void MyDelegate1(); public interface I1
Visual C# Consolidado
180
{ event MyDelegate1 MyEvent; } public delegate int MyDelegate2(string s); public interface I2 { event MyDelegate2 MyEvent; } public class ExplicitEventsSample: I1, I2 { public event MyDelegate1 MyEvent; // normal implementation of I1.MyEvent. event MyDelegate2 I2.MyEvent // explicit implementation of I2.MyEvent { add { MyEvent2Storage += value; } remove { MyEvent2Storage -= value; } } private MyDelegate2 MyEvent2Storage; // underlying storage for I2.MyEvent. private void FireEvents() { if (MyEvent != null) MyEvent(); if (MyEvent2Storage != null) MyEvent2Storage("helo"); } } public class MyClass { public static void Main() { } }
Palavra-chave new Em C#, a palavra-chave new pode utilizar como operador ou como modificador. •
Operador new é utilizado para criar objetos na pilha e invocar construtores.
•
Modificador new é utilizado para ocultar um membro herdado de um membro de classe-
base.
OPERADOR NEW O operador new é utilizado para criar objetos e invocar construtores, por exemplo: Class1 MyClass = new Class1();
Visual C# Consolidado
181
Também é utilizado com o fim de invocar o construtor predeterminado para tipos de valores, por exemplo: int myInt = new int(); Na instrução anterior se inicializa myInt com o valor 0, que é ou predeterminado para o tipo int. Essa instrução tno mesmo efeito que: int myInt = 0; Lembre que é um erro declarar um construtor predeterminado para um tipo struct, já que todos os tipos de valores posuem implícitamente um construtor público predeterminado. Não obstante, se podem se declarar construtores com parâmetros para um tipo struct. Os objetos do tipo valor, tais como as estruturas, são criados na pilha, enquanto que os objetos do tipo referencia, tais como as classes, são criados na pilha. O operador new não pode sobrecargar. Se o operador new fala na assinalação de memoria, iniciará a exceção OutOfMemoryException. Exemplo No seguinte exemplo, são criados e se inicializam, mediante o operador new, um objeto struct e um objeto class y, a continuação, se lhes assinalam valores. Os valores predeterminados e assinalados se mostram em tela. // cs_operator_new.cs // The new operator using System; class NewTest { struct MyStruct { public int x; public int y; public MyStruct (int x, int y) { this.x = x; this.y = y; } } class MyClass { public string name; public int id; public MyClass () { }
Visual C# Consolidado
182
public MyClass (int id, string name) { this.id = id; this.name = name; } } public static void Main() { // Criate objects using default construtors: MyStruct Ocation1 = new MyStruct(); MyClass Empoyee1 = new MyClass(); // Display values: Console.WriteLine("Default values:"); Console.WriteLine(" Struct members: {0}, {1}", Ocation1.x, Ocation1.y); Console.WriteLine(" Class members: {0}, {1}", Empoyee1.name, Empoyee1.id); // Criate objects using parameterized construtors:: MyStruct Ocation2 = new MyStruct(10, 20); MyClass Empoyee2 = new MyClass(1234, "John Martin Smith"); // Display values: Console.WriteLine("Assigned values:"); Console.WriteLine(" Struct members: {0}, {1}", Ocation2.x, Ocation2.y); Console.WriteLine(" Class members: {0}, {1}", Empoyee2.name, Empoyee2.id); } }
Class members: John Martin Smith, 1234 Observe no Exemplo que o valor predeterminado de uma série é null. Por tanto, não se mostra em tela.
MODIFICADOR NEW Use o modificador new para ocultar explícitamente um membro herdado de uma classe-base. Para ocultar um membro herdado, declare-o na classe derivada com o mesmo mome e modifiqueo com o modificador new. Considere a seguinte classe: public class MyBaseC { public int x; public void Invoke() {} } Ao declarar um membro com o nome Invoke em uma classe derivada se ocultará o método Invoke na classe-base, assim: public class MyDerivedC : MyBaseC { new public void Invoke() {} } Mas, o campo x não será afetado, já que não oculta nenhum mome similar. A ocultação de nomes por meio da herança toma uma das seguintes formas: •
Constante, campo, propriedade ou tipo introduzido em uma classe ou estrutura que oculta todos os membros da classe-base com o mesmo nome.
•
Método introduzido em uma classe o estrutura que oculta propriedades, campos e tipos, com o mesmo nome, na classe-base. Também oculta todos os métodos da classe-base com a mesma firma. Para obter mais informação, veja 3.6 Firmas e sobrecarga.
•
Indicador introduzido em uma classe o estrutura que oculta todos os indicadores da classebase com a mesma firma. É incorreto utilizar simultáneamente new e override no mesmo membro.
Se é utilizada o modificador new em uma declaração que não oculta um membro herdado, se gera uma advertencia. Exemplo Neste exemplo, uma classe-base, MyBaseC, e uma classe derivada, MyDerivedC, utilizam o mesmo mome de campo x, o que produza a ocultação do valor do campo herdado. o Exemplo demostra o uso do modificador new. Também mostra como obter acesso a os membros ocultos da classe-base mediante sus nomes completos. // cs_modifier_new.cs // The new modifier using System; public class MyBaseC { public static int x = 55;
Visual C# Consolidado
184
public static int e = 22; } public class MyDerivedC : MyBaseC { new public static int x = 100; // Name hiding public static void Main() { // Display the overlapping value of x: Console.WriteLine(x); // Access the hiddem value of x: Console.WriteLine(MyBaseC.x); // Display the unhiddem member y: Console.WriteLine(y); } }
Resultado 100 55 22 Se elimina o modificador new, ou programa seguirá compilándose e executándose, pois se obterá a advertencia: The keyword new is required on 'MyDerivedC.x' because it hides inherited member 'MyBaseC.x'. Também pode utilizar o modificador new para modificar um tipo anidado, Se o tipo anidado está ocultando outro tipo, como se mostra no seguinte exemplo. Exemplo Neste exemplo, uma classe anidada, MyClass, oculta uma classe com o mesmo mome na classebase. o Exemplo demostra o uso do modificador new para eliminar ou mensagem dadvertencia, assim como ou acesso a os membros da classe oculta mediante sus nomes completos. // cs_modifer_new_nested.cs // Using the new modifier with nested types using System; public class MyBaseC { public class MyClass { public int x = 200; public int y;
Visual C# Consolidado
185
} } public class MyDerivedC : MyBaseC { new public class MyClass // nested type hiding the base type members { public int x = 100; public int y; public int z; } public static void Main() { // Criating object from the overlapping class: MyClass S1 = new MyClass(); // Criating object from the hiddem class: MyBaseC.MyClass S2 = new MyBaseC.MyClass(); Console.WriteLine(S1.x); Console.WriteLine(S2.x); } }
Resultado 100 200
PALAVRA-CHAVE STRUCT Um tipo struct é um tipo de valor que pode conter construtores, constantes, campos, métodos, propriedades, indicadores, operadores, eventos e tipos anidados. A declaração de um tipo struct toma a forma seguinte: [attributes] [modifiers] s t r u c t identifier [: interfaces] body [; ] de onde: attributes (opcional) Informação declarativa adicional. Para obter mais informação sobre os atributos e as classes datributo, veja 17. Atributos. modifiers (opcional)
Visual C# Consolidado
186
Os modificadores permitidos são new e os cuatro modificadores de acesso . identifier Mome do tipo struct. interfaces (opcional) •
Lista que contém as interfaces implementadas pela estrutura, todas separadas por comas.
body •
Cuerpo da estrutura que contém as declarações de os membros.
Comentarios O tipo struct é adequado para representar objetos de poca complejidad, como puntos, rectánguos e cores. Mas é possível representar um ponto como uma classe, uma estrutura é mais eficaz em algunos casos. Por exemplo, se se declara uma matriz de 1000 objetos Point, se deberá assinalar memoria adicional para fazer referencia a cada objeto. Neste caso, a estrutura apresenta um menor costo. É um erro declarar um construtor predeterminado (sin parâmetros) para uma estrutura. Siempre existe um construtor predeterminado que inicializa os membros da estrutura com sus valores predeterminados. É um erro inicializar um campo de instancia de uma estrutura. Quando se cria um objeto struct mediante o operador new, se cria e se chama ao construtor apropriada. A diferença das classes, podem se criar instancias das estruturas sem utilizar o operador new. Se não é utilizado new, os campos permanecerão sem assinalar e ou objeto não se poderá utilizar até haver inicializado todos os campos. A diferença das classes, para as estruturas não existe herança. uma estrutura não pode heredar de outra estrutura ou classe, nem pode ser a base de uma classe. Sem embargo, as estruturas herdam da classe-base Object. uma estrutura pode implementar interfaces do mesmo modo que as classes. A diferença de C++, não pode declarar uma classe mediante a palavra-chave struct. Em C#, as classes e as estruturas são semánticamente diferentes. uma estrutura é um tipo de valor, enquanto que uma classe é um tipo de referencia. A menos que se necessite semántica de tipos de referencia, o sistema pode processar uma classe que ocupe menos de 16 bytes de forma mais eficaz como estrutura. Para obter mais informação sobre estruturas, veja 11. Estruturas e ou Tutorial de estruturas. Em as extensões administradas para C++, os equivalentes a uma classe do C# e a uma estrutura do C# são os seguintes: Extensões administradas para C++
Para obter mais informação...
class
__gc struct ou __gc class
palavra chave __gc
struct
__value struct ou __value class
palavra chave __value
C#
Exemplo 1 Este Exemplo mostra a inicialização de um tipo struct mediante construtores predeterminados e construtores com parâmetros. // keyword_struct.cs
Visual C# Consolidado
187
// struct declaration and initialization using System; public struct Point { public int x, y; public Point(int p1, int p2) { x = p1; e = p2; } } class MainClass { public static void Main() { // Initialize: Point myPoint = new Point(); Point yourPoint = new Point(10,10); // Display results: Console.Write("My Point: "); Console.WriteLine("x = {0}, e = {1}", myPoint.x, myPoint.y); Console.Write("Your Point: "); Console.WriteLine("x = {0}, e = {1}", yourPoint.x, yourPoint.y); } }
Resultados My Point: x = 0, e = 0 Your Point: x = 10, e = 10 Exemplo 2 Este Exemplo mostra uma característica exclusiva das estruturas. Cria um objeto Point sem utilizar o operador new. Se se reemplaza a palavra struct pela palavra class, ou programa não se compilará. // keyword_struct2.cs // Declare a struct object without "new" using System; public struct Point { public int x, y; public Point(int x, int y) { this.x = x; this.y = y; } } class MainClass { public static void Main() { // Declare an object:
PALAVRA-CHAVE AS O operador as é utilizado para realizar conversões entre tipos compatibles. o operador as é utilizado em expressões da forma: expression a s type de onde: expression Expressão de um tipo de referencia. type •
Tipo de referencia.
Comentarios O operador as funciona como um molde de conversão de tipos pero, se existe um erro na conversión, proporciona o valor null em vez de produzir uma exceção. mais formalmente, uma expressão da forma: expression as type equivale a: expression is type ? (type)expression : (type)null salvo que expression só se avalie uma vez. Deve ter-se em conta que o operador as somente executa conversões de referencia e conversões boxing. O operador as não pode realizar outras conversões, como as definidas pelo usuario, que deveriam ser realizadas utilizando expressões de conversão. Exemplo // cs_keyword_as.cs // The as operator using System; class MyClass1 { } class MyClass2
Visual C# Consolidado
189
{ } public class IsTest { public static void Main() { object [] myObjects = new object[6]; myObjects[0] = new MyClass1(); myObjects[1] = new MyClass2(); myObjects[2] = "helo"; myObjects[3] = 123; myObjects[4] = 123.4; myObjects[5] = null; for (int i=0; i
Resultado 0:not a string 1:not a string 2:'helo' 3:not a string 4:not a string 5:not a string
Palavra-chave explicit A palavra-chave explicit é utilizada para declarar um operador de conversão do tipo explícita definida pelo usuario (6.4.4 Conversões explícitas definidas pelo usuario). Por exemplo: class MyType { public static explicit operator MyType(int i) { // code to convert from int to MyType } } A diferença da conversão implícita, os operadores de conversão explícita devem invocarse mediante uma conversão explícita do tipo (cast). int i; MyType x = (MyType)i; // int-to-MyType requires cast
Visual C# Consolidado
190
Se não é utilizado esta conversão explícita, se produza um erro de compilação. Se uma operação de conversão do tipo pode produzir exceções ou pérdida de informação, deve definirse como explicit. Desta forma, se evita que o compilador realice a conversão automáticamente e se produzcam posibles consecuencias não desejadas. Exemplo O seguinte Exemplo define uma estrutura, Digit, que reapresenta um único dígito decimal. Se define um operador para conversões de byte a Digit, pois como não todos os bytes podem se converter em Digit, a conversão é explícita. // cs_keyword_explicit.cs using System; struct Digit { byte value; public Digit(byte value) { if (value>9) throw new ArgumentException(); this.value = value; } // define explicit byte-to-Digit conversion operator: public static explicit operator Digit(byte b) { Digit d = new Digit(b); Console.WriteLine("conversion occurred"); return d; } } class Test { public static void Main() { try { byte b = 3; Digit d = (Digit)b; // explicit conversion } catch (Exception e) { Console.WriteLine("{0} Exception caught.", e); } } }
Resultado conversion occurred
Palavra-chave null A palavra-chave null é um literal que representa uma referencia nula, assim, uma referencia que não aponta a nenhum objeto. Null é o valor predeterminado das variáveis de tipos de referencia.
Visual C# Consolidado
191
Palavra-chave switch A instrução switch é uma instrução de controle que permite manejar varias seleções e passar o controle a uma das instruções case de seu corpo. Apresenta a seguinte forma: s w i t c h ( expression) { c a s e constant-expression: statement jump-statement [d e f a u l t : statement jump-statement] } De onde: expression •
Expressão do tipo integral ou série.
statement Instruções que se devem executar se se transfere o controle à etiqueta caSe o default. jump-statement Instrução de salto que transfere o controle fora do corpo case. constant-expression O controle se transfere a uma instrução case específica segundo o valor desta expressão. Comentarios O controle se transfere à instrução case cuja constante constant-expression coincide com a expressão expression. A instrução switch pode incluir qualquer número de elementos case, pois não pode haver dos constantes case com o mesmo valor em uma mesma instrução switch. A execução do corpo da instrução empieza na instrução selecionada e continúa até que a instrução de salto jump-statement transfere o controle fora do corpo case. Observe que é necessário colocar jump-statement ao final de cada boque, incluido ou último boque, já seja uma instrução caSe o uma instrução default. A diferença da instrução switch de C++, C# não admite ou paso explícito de uma etiqueta case a outra. Se o deseja, pode utilizar goto a uma etiqueta caSe o goto default. Se expression não coincide com nenhuma constante constant-expression, o controle se transfere às instruções que seguem à etiqueta default opcional. Se não existe uma etiqueta default, o controle se transfere fora da instrução switch. Exemplo // statements_switch.cs using System; class SwitchTest { public static void Main() { Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large"); Console.Write("Please enter your selection: ");
Visual C# Consolidado
192
string s = Console.ReadLine(); int n = int.Parse(s); int cost = 0; switch(n) { case 1: cost += 25; break; case 2: cost += 25; goto case 1; case 3: cost += 50; goto case 1; default: Console.WriteLine("Invalid selection. Please select 1, 2, or 3."); break; } if (cost != 0) Console.WriteLine("Please insert {0} cents.", cost); Console.WriteLine("Thank you for your business."); } } Entrada 2
Resultados do Exemplo Coffee sizes: 1=Small 2=Medium 3=Large Please enter your selection: 2 Please insert 50 cents. Thank you for your business. Descrição do código No Exemplo anterior, se utilizou uma variável do tipo integral, n, para os casos da instrução switch. Observe que também pode utilizar a variável de série, s, diretamente. Nesse caso, a estrutura switch pode apresentar a seguinte forma: switch(s) { case "1": ... case "2": ...
Visual C# Consolidado
193
} • Mas não se admite passar explícitamente de uma etiqueta de caso a outra, se está permitido apilhar etiquetas de caso, por exemplo: case 0: case 1: // do something;
Palavra-chave base A palavra-chave base é utilizada para obter acesso a os membros da classe-base desde uma classe derivada: •
Realice uma chamada a um método da classe-base substituído por outro método.
• Especifique a qué construtor da classe-base deve chamar para criar instancias da classe derivada. O acesso a uma classe-base só se permite em um construtor, em um método de instancia ou em um descritor de acesso a uma propriedade de instancia. É incorreto utilizar a palavra-chave base dentro de um método estático. Exemplo Neste exemplo, tanto a classe-base, Person, como a classe derivada, Empoyee, posuem um método denominado Getinfo. Mediante a palavra-chave base, pode realizar uma chamada ao método Getinfo da classe-base desde a classe derivada. // keywords_base.cs // Accessing base class members using System; public class Person { protected string ssn = "444-55-6666"; protected string name = "John L. Malgraine"; public virtual void GetInfo() { Console.WriteLine("Name: {0}", name); Console.WriteLine("SSN: {0}", ssn); } } class Empoyee: Person { public string id = "ABC567EFG"; public override void GetInfo() { // Calling the base class GetInfo method: base.GetInfo(); Console.WriteLine("Empoyee ID: {0}", id); } } class TestClass { public static void Main() { Empoyee E = new Empoyee();
Visual C# Consolidado
194
E.GetInfo(); } }
Resultado Name: John L. Malgraine SSN: 444-55-6666 Empoyee ID: ABC567EFG Exemplo Este Exemplo mostra como especificar o construtor da classe-base o que se realiza a chamada quando são criados instancias de uma classe derivada. // keywords_base2.cs using System; public class MyBase { int num; public MyBase() { Console.WriteLine("in MyBase()"); } public MyBase(int i ) { num = i; Console.WriteLine("in MyBase(int i)"); } public int GetNum() { return num; } } public class MyDerived: MyBase { // This construtor will call MyBase.MyBase() public MyDerived() : base() { } // This construtor will call MyBase.MyBase(int i) public MyDerived(int i) : base(i) { } public static void Main() { MyDerived md = new MyDerived(); MyDerived md1 = new MyDerived(1); } }
Visual C# Consolidado
195
Resultado in MyBase() in MyBase(int i)
Palavra-chave extern Use o modificador extern em uma declaração de método para indicar que o método se implementa externamente. um uso habitual do modificador extern é com o atributo DllImport. Veja DllImportAttribute (Classe) para obter mais informação. É incorreto utilizar simultáneamente os modificadores abstract e extern para modificar o mesmo membro. O uso do modificador extern significa que o método se implementa fora do código do C#, enquanto que o uso do abstract significa que a implementação do método não se inclui na classe. Como uma declaração de método externo não proporciona uma implementação, não existe corpo do método; a declaração de método finaliza simplemente com um ponto e vírgula e sem chaves ({ }) depois da firma. Por exemplo: public static extern int MyMethod(int x); Nota o uso da palavra-chave extern é mais limitado que em C++. Para comparara com a palavra-chave de C++, veja Utilizar extern para especificar vinculação na Referencia do lenguaje C++. Exemplo Neste exemplo, ou programa recibe uma série do usuario e a mostra dentro de um quadro de mensagem. o programa utiliza ou método MessageBox importado da biblioteca User32.dll. using System; using System.Runtime.InteropServices; class MyClass { [DllImport("User32.dll")] public static extern int MessageBox(int h, string m, string c, int type); public static int Main() { string myString; Console.Write("Enter your message: "); myString = Console.ReadLine(); return MessageBox(0, myString, "My Message Box", 0); } } Execução de Exemplo Enter your message: Where do you want to go today? Tras escrever o texto anterior, aparece na pantala um quadro de mensagem com ese texto. Exemplo Este Exemplo utiliza dos arquivos, CM.cs e Cmdll.c, para demostrar o uso de extern. o arquivo C é uma DLL externa que se invoca desde ou programa escrito em C#.
Arquivo CM.cs // cm.cs using System; using System.Runtime.InteropServices; public class MyClass { [DllImport("Cmdll.dll")] public static extern int MyMethod(int x); public static void Main() { Console.WriteLine("MyMethod() returns {0}.", MyMethod(5)); } }
Resultado MyMethod() returns 50.
Compilação Para gerar ou proyecto, siga estes pasos: •
Compile Cmdll.c como uma DLL mediante a línea de comandos de Visual C++:
cl /LD /MD Cmdll.c •
Compile CM.cs mediante a línea de comandos:
csc CM.cs Desta forma, se criará o arquivo executable CM.exe. Quando execute este programa, MyMethod passará o valor 5 ao arquivo DLL, o qual devoltará o valor multiplicado por 10.
Palavra-chave object O tipo object é um alias de System.Object do .NET Framework. As variáveis do tipo object podem receber valores de qualquer tipo. Todos os tipos de dados, predefinidos e definidos pelo usuario, herdam da classe System.Object. ou tipo de dados object é ou tipo hacia o qual e desde o qual os objetos se conviertem mediante boxing. Exemplo O seguinte Exemplo mostra como as variáveis do tipo object podem aceitar valores de qualquer tipo de dados e como podem utilizar métodos de System.Object procedentes do .NET Framework. // keyword_object.cs using System; public class MyClass1 { public int i = 10;
Visual C# Consolidado
197
} public class MyClass2 { public static void Main() { object a; a = 1; // an example of boxing Console.WriteLine(a); Console.WriteLine(a.GetType()); Console.WriteLine(a.ToString()); Console.WriteLine(); a = new MyClass1 (); MyClass1 ref_MyClass1; ref_MyClass1 = (MyClass1)a; Console.WriteLine(ref_MyClass1.i); } }
Resultados 1 System.Int32 1 10
Palavra-chave this A palavra-chave this faz referencia à instancia atual da classe. As funções membro estáticas não apresentam um ponteiro this. Esta palavra-chave this pode ser utilizada para obter acesso a membros desde construtores, métodos de instancia e descritores de acesso de instancias. A continuação, se indicam algunos usos comunes de this: • Obter acesso a membros com o fim de evitar ambigüedades com nomes similares, por exemplo: public Empoyee(string name, string alias) { this.name = name; this.alias = alias; } •
Passar um objeto como parâmetro a outros métodos, por exemplo, para:
CalcTax(this); •
Declarar indicadores, por exemplo:
public int this [int param] { get { return array[param]; } set {
Visual C# Consolidado
198
array[param] = value; } } É incorreto fazer referencia a this em um método estático, em um descritor de acesso a uma propriedade estática ou em um inicializador de variável de uma declaração de campo. Exemplo Neste exemplo, this é utilizado para obter acesso a os membros da classe Empoyee, name e alias, que apresentam ambigüedad com nomes similares. Também é utilizado para passar um objeto ao método CalcTax, o qual pertence a outra classe. // keywords_this.cs // this example using System; public class Empoyee { public string name; public string alias; public decimal salary = 3000.00m; // Construtor: public Empoyee(string name, string alias) { // Use this to qualify the fields, name and alias: this.name = name; this.alias = alias; } // Printing method: public void printEmpoyee() { Console.WriteLine("Name: {0}\nAlias: {1}", name, alias); // Passing the object to the CalcTax method by using this: Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this)); } } public class Tax { public static decimal CalcTax(Empoyee E) { return (0.08m*(E.salary)); } } public class MainClass { public static void Main() { // Criate objects: Empoyee E1 = new Empoyee ("John M. Trainer", "jtrainer"); // Display results: E1.printEmpoyee(); }
Visual C# Consolidado
199
}
Resultado Name: John M. Trainer Alias: jtrainer Taxes: $240.00
Palavra-chave bool A palavra-chave bool é um alias de System.Boolean. É utilizado para declarar variáveis que armazenam os valores booleanos true e false. Literais É possível assinalar um valor booleano a uma variável do tipo bool, por exemplo: bool MyVar = true; Também pode assinalar uma expressão que se avalie como bool a uma variável do tipo bool, por exemplo: bool Alphabetic = (c > 64 && c < 123); Conversões Em C++, um valor do tipo bool pode converter em um valor do tipo int; assim: false equivale a cero e true equivale a valores distintos de cero. Em C#, não é possível realizar a conversão do tipo bool a outros tipos ou viceversa. Por exemplo, a seguinte instrução if não é válida em C#, mas se o é em C++: int x = 123; if (x) // Invalid in C# { printf("The value of x is nonzero."); } Para provar uma variável do tipo int, tem que comparara explícitamente com um valor (por exemplo, cero); assim: int x = 123; if (x != 0) // The C# way { Console.Write("The value of x is nonzero."); } Exemplo Neste exemplo, se escreve um carácter desde ou teclado e ou programa comprova se se trata de uma letra. Nesse caso, comprova se é minúscula ou maiúscula. Em cada caso, se mostra a mensagem apropriada. // keyword_bool.cs // Character Tester using System; public class BoolTest { public static void Main() { Console.Write("Enter a character: "); char c = (char) Console.Read(); if (Char.IsLetter(c))
Visual C# Consolidado
200
if (Char.IsOwer(c)) Console.WriteLine("The character is owercase."); else Console.WriteLine("The character is uppercase."); else Console.WriteLine("The character is not an alphabetic character."); } } Entrada X
Resultados do Exemplo Enter a character: X The character is uppercase. Sucesivas execuções de Exemplo podrían ter este aspecto: Enter a character: x The character is owercase. Enter a character: 2 The character is not an alphabetic character.
Palavra-chave false Em C#, a palavra-chave false pode utilizar como um operador sobrecarregado ou como um literal. •
Operador false
•
Literal false
OPERADOR FALSE Em os tipos definidos pelo usuario pode definir um operador false que devolve o valor do tipo bool true para indicar um valor lógico falso; caso contrario, devolve false. Isto resulta útil para tipos que representam valores true, false e null (nem true nem false), como os utilizados em base de dados. Esses tipos podem se utilizar em as expressões de controle das instruções if, do, while e for, assim como em expressões condicionales. Se um tipo define false como operador, também deve definir true como operador. Um tipo não pode sobrecarregar diretamente os operadores lógicos condicionais (&& e ||), pois pode conseguir um efeito equivalente se se sobrecarrega os operadores lógicos normais e os operadores true e false (veja 7.11.2 Operadores lógicos condicionais definidos pelo usuario). Exemplo Veja o Exemplo de 11.4.2 Tipo boolean para base de dados.
FALSE (LITERAL) A palavra-chave false é um literal do tipo bool que reapresenta o valor lógico "falso". Exemplo // cs_keyword_false.cs using System;
Visual C# Consolidado
201
class test { public static void Main() { bool a = false; Console.WriteLine( a ? "yes" : "no" ); } }
Resultado no
Palavra-chave operator A palavra-chave operator é utilizado para declarar um operador em uma declaração de classe o estrutura. uma declaração de operador pode apresentar uma das seguintes cuatro formas: p u b l i c s t a t i c result-type o p e r a t o r unary-operator ( op-type operand ) p u b l i c s t a t i c result-type o p e r a t o r binary-operator ( op-type operand, op-type2 operand2 ) p u b l i c s t a t i c i m p l i c i t o p e r a t o r conv-type-out ( conv-type-in operand ) p u b l i c s t a t i c e x p l i c i t o p e r a t o r conv-type-out ( conv-type-in operand ) de onde: result-type •
Tipo do resultado do operador.
unary-operator Unão de os seguintes: + - ! ~ ++
— true false
op-type •
Tipo do primeiro (o único) parâmetro.
operand •
Mome do primeiro (o único) parâmetro.
binary-operator Unão de os seguintes:
^ << >> == != > < >= <=
op-type2 •
Tipo do segundo parâmetro.
operand2 •
Mome do segundo parâmetro.
conv-type-out •
Tipo de destinão de um operador de conversão de tipos.
conv-type-in •
Tipo de entrada de um operador de conversão de tipos.
Visual C# Consolidado
202
Comentarios As dos primeras formas declaram operadores definidos pelo usuario que sobrecarrega operadores integrados. Tenga em cuenta que não todos os operadores integrados podem sobrecargarse (veja Operadores sobrecargables). Ao menos unão de os tipos op-type e op-type2 deve ser ou tipo contenedor (assim, ou tipo do qual é membro ou operador). De este modo, por exemplo, se evita ter que redefinir o operador dadição de inteiros. As dos últimas formas declaram operadores de conversión. Só unão de os tipos conv-type-in e conv-type-out deve ser ou tipo contenedor (assim, um operador de conversão só pode realizar conversões de seu tipo contenedor a outro tipo, ou de outro tipo a seu tipo contenedor). Os operadores só podem tomar parâmetros de valor, não parâmetros ref ou out. Qualquer declaração de operador pode estar precedida por uma lista opcional de atributos. Exemplo A continuação, se mostra uma classe muy simplificada para números racionales. Sobrecarga os operadores + e * para implementar a adição e multiplicação de números fraccionarios, e também proporciona um operador que convierte fracções em números reales do tipo double. // cs_keyword_operator.cs using System; class Fraction { int num, den; public Fraction(int num, int den) { this.num = num; this.dem = den; } // overoad operator + public static Fraction operator +(Fraction a, Fraction b) { return new Fraction(a.num * b.dem + b.num * a.den, a.dem * b.den); } // overoad operator * public static Fraction operator *(Fraction a, Fraction b) { return new Fraction(a.num * b.num, a.dem * b.den); } // define operator double public static implicit operator double(Fraction f) { return (double)f.num / f.den; } } class Test { public static void Main() { Fraction a = new Fraction(1, 2); Fraction b = new Fraction(3, 7);
Visual C# Consolidado
203
Fraction c = new Fraction(2, 3); Console.WriteLine((double)(a * b + c)); } }
Resultado 0.880952380952381
Palavra-chave throw A instrução throw é utilizado para señalizar a aparição de uma situação anómaa (exceção) durante a execução do programa. Apresenta a seguinte forma: t h r o w [expression]; de onde: expression O objeto exceção. Este elemento se omite se se vuelve a iniciar ou objeto de exceção atual em uma cláusula catch. Comentarios A exceção provocada é um objeto cuja classe é derivada de System.Exception, por exemplo: class MyException : System.Exception {} throw new MyException(); Normalmente, a instrução throw é utilizado com as instruções try-catch ou try-finally. Quando se provoca uma exceção, ou programa busca a instrução catch que controa esa exceção. Também pode voltar a iniciar uma exceção detectada mediante a instrução throw. Exemplo Este Exemplo mostra como provocar uma exceção mediante a instrução throw. // throw example using System; public class ThrowTest { public static void Main() { string s = null; if (s == null) { throw(new ArgumentNullException()); } Console.Write("The string s is null"); // not executed } }
Resultado Se produza a exceção seguinte: System.ArgumentNullException
Visual C# Consolidado
204
Palavra-chave break A instrução break permite terminar a instrução switch ou o laço envolvente em os quais aparece. o controle se transfere à instrução que sigue à instrução terminada, se existe alguna. A instrução apresenta a seguinte forma: break; Exemplo Neste exemplo, a instrução condicional contém um contador preparado para contar de 1 a 100; sem embargo, a instrução break termina ou laço tras 4 iterações. // statements_break.cs using System; class BreakTest { public static void Main() { for (int i = 1; i <= 100; i++) { if (i == 5) break; Console.WriteLine(i); } } }
Resultado 1 2 3 4 Exemplo Este Exemplo mostra o uso de break em uma instrução switch. // statements_break2.cs // break and switch using System; class Switch { public static void Main() { Console.Write("Enter your selection (1, 2, or 3): "); string s = Console.ReadLine(); int n = Int32.Parse(s); switch(n) { case 1: Console.WriteLine("Current value is {0}", 1); break; case 2: Console.WriteLine("Current value is {0}", 2); break;
Visual C# Consolidado
205
case 3: Console.WriteLine("Current value is {0}", 3); break; default: Console.WriteLine("Sorry, invalid selection."); break; } } } Entrada 1
Resultados do Exemplo Enter your selection (1, 2, or 3): 1 Current value is 1 Se se escreveu 4, ou resultado sería: Enter your selection (1, 2, or 3): 4 Sorry, invalid selection.
Palavra-chave try-finally O bloco finally é útil para liberar os recursos assinalados no bloco try. o controle se transfere siempre ao bloco finally independientemente de como finalice o bloco try. A instrução apresenta a seguinte forma: t r y try-bock f i n a l l y finally-bock de onde: try-bock •
Contém o segmento de código que pode produzir a exceção.
finally-bock •
Contém o controlador da exceção e ou código que realiza a liberação de recursos.
Comentarios Se biem catch é utilizado para controlar exceções que ocurrem em um bloco de instrucções, finally é utilizado para garantizar que um bloco de código se executa independientemente de como finaliza o bloco try anterior. Exemplo Neste exemplo, existe uma instrução de conversão não válida que produza uma exceção. Se se executa ou programa, se obtem um mensagem de erro em tiempo de execução, pois a cláusula finally se executa de todas formas e mostra o resultado. // try-finally using System; public class TestTryFinally { public static void Main() { int i = 123; string s = "Some string"; object ou = s;
Visual C# Consolidado
206
try { // Invalid conversion; ou contains a string not an int i = (int) o; } finally { Console.Write("i = {0}", i); } } }
Resultado Se produza a exceção seguinte: System.InvalidCastException Mas se capturó uma exceção, a instrução de salida incluida no bloco finally se executará de todas formas, assim: i = 123 Para obter mais informação acerca de finally, veja try-catch-finally.
Palavra-chave out A palavra-chave out aplicada a parâmetros de métodos faz que um método haga referencia à variável pasada ao método. Qualquer cambio que se realice no parâmetro dentro do método se reflejará em esa variável quando se devuelva o controle ao método que realizó a chamada. Declarar um método como out é útil quando se deseja que devuelva varios valores. um método que utiliza um parâmetro out puede, não obstante, seguir devolviendo um valor. um método pode ter mais de um parâmetro out. Para utilizar um parâmetro out, ou argumento deve passarse explícitamente ao método como um argumento out. o valor de um argumento out não se passará ao parâmetro out. Uma variável que se pasa como argumento out não necessita inicializarse. Não obstante, deve assinalarse um valor ao parâmetro out antes de que o método devuelva a chamada. Uma propriedade não é uma variável y, por tanto, não pode passar como parâmetro out. Se as declarações de dois métodos só se diferençan no uso de out, existirá sobrecarga. Sem embargo, não é possível definir uma sobrecarga que só se diferencie em ref e out. Por exemplo, as seguintes declarações de sobrecarga são válidas: class MyClass { public void MyMethod(int i) {i = 10;} public void MyMethod(out int i) {i = 10;} } pois as seguintes não o son: class MyClass { public void MyMethod(out int i) {i = 10;} public void MyMethod(ref int i) {i = 10;} } Exemplo
Visual C# Consolidado
207
// cs_out.cs using System; public class MyClass { public static int TestOut(out char i) { i = 'b'; return -1; } public static void Main() { char i; // variável need not be initialized Console.WriteLine(TestOut(out i)); Console.WriteLine(i); } }
Resultado -1 b
Palavra-chave true Em C#, a palavra-chave true pode utilizar como um operador sobrecarregado ou como um literal: •
Operador true
•
Literal true
OPERADOR TRUE Em os tipos definidos pelo usuario pode definir um operador true que devolve o valor do tipo bool true para indicar um valor lógico verdadero; caso contrario, devolve false. Isto resulta útil para tipos que representam valores true, false e null (nem true nem false), como os utilizados em base de dados. Esses tipos podem se utilizar em as expressões de controle das instruções if, do, while e for, assim como em expressões condicionales. Se um tipo define true como operador, também deve definir false como operador. Um tipo não pode sobrecarregar diretamente os operadores lógicos condicionais (&& e ||), pois pode conseguir um efeito equivalente se se sobrecarrega os operadores lógicos normais e os operadores true e false (veja 7.11.2 Operadores lógicos condicionais definidos pelo usuario). Exemplo Veja o Exemplo de 11.4.2 Tipo boolean para base de dados.
TRUE (LITERAL) A palavra-chave true é um literal do tipo bool que reapresenta o valor lógico "verdadero". Exemplo // cs_keyword_true.cs using System; class test
Visual C# Consolidado
208
{ public static void Main() { bool a = true; Console.WriteLine( a ? "yes" : "no" ); } }
Resultado yes
Palavra-chave byte A palavra-chave byte denota um tipo integral que armazena valores segundo se indica na taba seguinte. Tipo
Intervalo
Tamanho
Tipo do .NET Framework
byte
0 a 255
Inteiro de 8 bits sem signo
System.Byte
Literais As variáveis do tipo byte podem se declarar e inicializar como no seguinte exemplo: byte myByte = 255; Na declaração anterior, ou literal inteiro 255 se convierte implícitamente do tipo int ao tipo byte. Se o literal inteiro supera ou intervalo de valores do tipo byte, se produzirá um erro de compilação. Conversões Existe uma conversão implícita predefinida de byte a short, ushort, int, uint, ong, uong, foat, double ou decimal. Não podem se converter implícitamente tipos numéricos não literais cujo tamanho darmazenamiento seja superior a byte (veja Tabela de tipos integrais para conhecer os tamanhos darmazenamiento de os tipos integrais). Considere, por exemplo, as dos seguintes variáveis do tipo byte, x e y: byte x = 10, e = 20; A instrução dassinalação seguinte produzirá um erro de compilação, já que a expressão aritmética do lado direito do operador dassinalação se avalie de forma predeterminada como int. byte z = x + y; // Erro: conversion from int to byte Para solucionar este problema, utilize uma conversão explícita: byte z = (byte)(x + y); // OK: explicit conversion Mas, é possível utilizar as instruções seguintes, de onde a variável de destinão tem um tamanho darmazenamiento igual ou superior: int x = 10, e = 20; int m = x + y; ong n = x + y;
Visual C# Consolidado
209
Assim mesmo, não existe conversão implícita de tipos de ponto flutuante a tipo byte. Por exemplo, a instrução seguinte gerará um erro de compilação, a menos que se utilize uma conversão explícita: byte x = 3.0; // Erro: não implicit conversion from double byte e = (byte)3.0; // OK: explicit conversion Para chamar os métodos sobrecarregados, deve se utilizar uma conversão explícita de tipos. Considere, por exemplo, os dos seguintes métodos sobrecarregados que utilizam parâmetros do tipo byte e int: public static void MyMethod(int i) {} public static void MyMethod(byte b) {} Se é utilizada a conversão ao tipo byte, se garante a chamada ao tipo correto; por exemplo: MyMethod(5); // Calling the method with the int parameter MyMethod((byte)5); // Calling the method with the byte parameter Para obter mais informação sobre expressões aritméticas com tipos de ponto flutuante e tipos integrais, veja foat e double. Para obter mais informação sobre as regas de conversão numérica implícitas, veja a Taba de conversões numéricas implícitas.
Palavra-chave fixed Impide que o recolector de elementos não utilizados cambie a colocação de uma variável. Apresenta a seguinte forma: f i x e d ( type* ptr = expr ) statement de onde: type Tipo não administrado ou tipo void. ptr •
Mome de ponteiro.
expr Expressão que pode converter implícitamente em um tipo type*. statement •
Instrução o bloco executable.
Comentarios A instrução fixed só se permite em um contexto unsafe. A instrução fixed establece um ponteiro em uma variável administrada e "fija" esa variável durante a execução da instrução o bloco statement. Sem fixed, os ponteiros a variáveis administradas serían de poca utilidad, já que o proceso de recoleção de elementos não utilizados poderia cambiar a colocação das variáveis de forma impredecible. De hecho, ou compilador do C# não permite definir um ponteiro a uma variável administrada se não é em uma instrução fixed. // assume class Point { public int x, y; } Point pt = new Point(); // pt is a managed variável, subject to g.c. fixed ( int* p = &pt.x ){ // must use fixed to get address of pt.x and *p = 1; // pin pt in place while we use the pointer } Um ponteiro pode inicializar com a direção de uma matriz ou de uma série:
Visual C# Consolidado
210
fixed (int* p = arr) ... // equivalent to p = &arr[0] fixed (char* p = str) ... // equivalent to p = &str[0] Se podem inicializar varios ponteiros à vez, siempre que sean do mesmo tipo: fixed (byte* ps = srcarray, pd = dstarray) {...} Para inicializar ponteiros de diferente tipo, simplemente anide instruções fixed: fixed (int* p1 = &p.x) fixed (double* p2 = &array[5]) // do something with p1 and p2 Os ponteiros inicializados em instruções fixed não podem se modificar. Depois de executar a instrução o bloco statement, qualquer variável anteriormente fijada queda já sometida ao proceso de recoleção de elementos não utilizados. Por consiguiente, não deve apuntar a esas variáveis desde fora da instrução fixed. no modo não seguro (unsafe), pode assinalar memoria à pilha, de onde não está sometida a recoleção de elementos não utilizados y, por o tanto, não necessita fijarse. Veja stackaloc para obter mais informação. Exemplo // statements_fixed.cs // compile with: /unsafe using System; class Point { public int x, y; } class FixedTest { // unsafe method: takes pointer to int unsafe static void SquarePtrParam (int* p) { *p *= *p; } unsafe public static void Main() { Point pt = new Point(); pt.x = 5; pt.y = 6; // pin pt in place: fixed (int* p = &pt.x) { SquarePtrParam (p); } // pt now unpinned Console.WriteLine ("{0} {1}", pt.x, pt.y); } }
Resultado 25 6
Visual C# Consolidado
211
Palavra-chave override Utilize o modificador override para modificar um método, uma propiedad, um indicador ou um evento. Os métodos de reemplazo proporcionam uma nueva implementação de um membro herdado de uma classe-base. ou método substituído por uma declaração override se conhece como método base reemplazado. ou método base substituído deve ter a mesma firma que o método de reemplazo. Não pode substituir um método estático ou não virtual. ou método base substituído deve ser virtual, abstract u override. Uma declaração override não pode cambiar a accesibilidad do método virtual. Tanto ou método de reemplazo como ou método virtual devem ter o mesmo modificador de nivo de acesso . Não podem se utilizar os seguintes modificadores para modificar um método de reemplazo: new
static
virtual
abstract
Uma declaração de propriedade de reemplazo deve especificar o mesmo modificador de acesso , tipo e mome que a propriedade herdada, e a propriedade reemplazada deve ser virtual, abstract u override. Para obter mais informação acerca do acesso a os membros de uma classe-base, veja 7.5.8 acesso base. Para obter mais informação sobre como substituir métodos, veja 10.5.4 Métodos de reemplazo. Exemplo Veja o Exemplo correspondiente da palavra-chave virtual. Desde dentro da classe derivada que posee um método de reemplazo, aún é possível ter acesso , mediante a palavra-chave base, ao método base substituído que tno mesmo nome. Por exemplo, se se dispõe de um método virtual MyMethod(), e um método de reemplazo em uma classe derivada, pode obter acesso ao método virtual desde a classe derivada mediante a chamada: base.MyMethod() Compare esta opção com a de C++, de onde é utilizado o operador de resolução de ámbito (::) e o nome da classe-base, por exemplo: My_Base_Class_Name::MyMethod() Exemplo Neste exemplo, existe uma classe-base, Square, e uma classe derivada, Cube. Como a área de um cubo é a soma das áreas de seis quadrados, é possível calcular mediante uma chamada ao método Area() da classe-base. // cs_override_keyword.cs // Calling overridem methods from the base class using System; class TestClass { public class Square { public double x; // Construtor: public Square(double x) { this.x = x; }
Visual C# Consolidado
212
public virtual double Area() { return x*x; } } class Cube: Square { // Construtor: public Cube(double x): base(x) { } // Calling the Area base method: public override double Area() { return (6*(base.Area())); } } public static void Main() { double x = 5.2; Square s = new Square(x); Square c = new Cube(x); Console.WriteLine("Area of Square = {0:F2}", s.Area()); Console.WriteLine("Area of Cube = {0:F2}", c.Area()); } }
Resultado Area of Square = 27.04 Area of Cube = 162.24
Palavra-chave try-catch A instrução try-catch consta de um bloco try seguido de uma ou mais cláusulas catch, as quais especificam controladores para diferentes exceções . Esta instrução apresenta uma das seguintes formas: t r y try-bock c a t c h ( exception-declaration-1) catch-bock-1 c a t c h ( exception-declaration-2) catch-bock-2 ... t r y try-bock c a t c h catch-bock de onde: try-bock •
Contém o segmento de código que pode produzir a exceção.
O bloco try-bock Contém o bloco de código suceptível de causar a exceção. Este bloco se executa até que se produza uma exceção ou até completarse satisfatoriamente. Por exemplo, ou seguinte intento de converter o tipo de um objeto null provoca a exceção NullReferenceException: object o2 = null; try { int i2 = (int) o2; // Erro } A cláusula catch pode utilizar sem argumentos, em cujo caso captura qualquer tipo de exceção e se conhece como cláusula catch geral. Também pode aceitar um argumento de objeto derivado de System.Exception, em cujo caso trata uma exceção específica. Por exemplo: catch (InvalidCastException e) { } É possível utilizar mais de uma cláusula catch específica na mesma instrução try-catch. Neste caso, a ordem das cláusulas catch é importante já que estas se examinam por ordem. As exceções mais específicas se capturam anté que as menos específicas. Se pode utilizar uma instrução throw no bloco catch para voltar a provocar a exceção capturada pela instrução catch. Por exemplo: catch (InvalidCastException e) { throw (e); // Rethrowing exception e } Se deseja voltar a provocar a exceção que está sendo atualmente controlada por uma cláusula catch sem parâmetros, use a instrução throw sem argumentos. Por exemplo: catch { throw; } Quando estes dentro de um bloco try, inicialice só variáveis declaradas em seu interior; caso contrario, pode provocarse uma exceção anté de que se complete a execução do boque. Por exemplo, no seguinte Exemplo de código, a variável x se inicializa dentro do bloco try. Ao intentar utilizar a variável fora do bloco try, na instrução Write(x), se gerará ou seguinte erro do compilador: Uso de variável ocal não assinalada. public static void Main() { int x; try { x = 123; // Don't do that. // ... } catch { // ... } Console.Write(x); // Erro: Use of unassigned ocal variável 'x'. }
Visual C# Consolidado
214
Exemplo Neste exemplo, o bloco try contém uma chamada ao método MyFn(), que pode produzir uma exceção. A cláusula catch Contém o controlador da exceção, o qual simplemente mostra um mensagem na tela. Quando se realiza a chamada à instrução throw desde dentro de MyFn(), o sistema busca a instrução catch e mostra a mensagem Exception caught. // Rethrowing exceptions: using System; class MyClass { public static void Main() { MyClass x = new MyClass(); try { string s = null; x.MyFn(s); } catch (Exception e) { Console.WriteLine("{0} Exception caught.", e); } } public void MyFn(string s) { if (s == null) throw(new ArgumentNullException()); } }
Resultado Se produza a exceção seguinte: System.ArgumentNullException Exemplo Neste exemplo, se utilizam dos instruções catch. A exceção mais específica, que aparece em primeiro lugar, se captura primero. // Ordering catch clauses using System; class MyClass { public static void Main() { MyClass x = new MyClass(); try { string s = null; x.MyFn(s); } // Most specific: catch (ArgumentNullException e)
Visual C# Consolidado
215
{ Console.WriteLine("{0} First exception caught.", e); } // Least specific: catch (Exception e) { Console.WriteLine("{0} Second exception caught.", e); } } public void MyFn(string s) { if (s == null) throw new ArgumentNullException(); } }
Resultado Se produza a exceção seguinte: System.ArgumentNullException No Exemplo anterior, se empieza com a cláusula catch menos específica, se obterá o mensagem: A previous catch clause already catché all exceptions of this or a super type ('System.Exception') Não obstante, para capturar a exceção menos específica, deve substituir a instrução throw pela seguinte: throw new Exception();
Palavra-chave switch A instrução switch é uma instrução de controle que permite manejar varias seleções e passar o controle a uma das instruções case de seu cuerpo. Apresenta a seguinte forma: s w i t c h ( expression) { c a s e constant-expression: statement jump-statement [d e f a u l t : statement jump-statement] } De onde: expression •
Expressão do tipo integral ou série.
statement Instruções que se devem executar se se transfere o controle à etiqueta caSe o default. jump-statement Instrução de salto que transfere o controle fora do corpo case. constant-expression
Visual C# Consolidado
216
O controle se transfere a uma instrução case específica segundo o valor desta expressão. Comentarios O controle se transfere à instrução case cuja constante constant-expression coincide com a expressão expression. A instrução switch pode incluir qualquer número de elementos case, pois não pode haver dos constantes case com o mesmo valor em uma mesma instrução switch. A execução do corpo da instrução empieza na instrução selecionada e continúa até que a instrução de salto jump-statement transfere o controle fora do corpo case. Observe que é necessário colocar jump-statement ao final de cada boque, incluido ou último boque, já seja uma instrução caSe o uma instrução default. A diferença da instrução switch de C++, C# não admite ou paso explícito de uma etiqueta case a outra. Se o deseja, pode utilizar goto a uma etiqueta caSe o goto default. Se expression não coincide com nenhuma constante constant-expression, o controle se transfere às instruções que seguem à etiqueta default opcional. Se não existe uma etiqueta default, o controle se transfere fora da instrução switch. Exemplo // statements_switch.cs using System; class SwitchTest { public static void Main() { Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large"); Console.Write("Please enter your selection: "); string s = Console.ReadLine(); int n = int.Parse(s); int cost = 0; switch(n) { case 1: cost += 25; break; case 2: cost += 25; goto case 1; case 3: cost += 50; goto case 1; default: Console.WriteLine("Invalid selection. Please select 1, 2, or 3."); break; } if (cost != 0) Console.WriteLine("Please insert {0} cents.", cost); Console.WriteLine("Thank you for your business."); } } Entrada 2
Visual C# Consolidado
217
Resultados do Exemplo Coffee sizes: 1=Small 2=Medium 3=Large Please enter your selection: 2 Please insert 50 cents. Thank you for your business. Descrição do código No Exemplo anterior, se utilizou uma variável do tipo integral, n, para os casos da instrução switch. Observe que também pode utilizar a variável de série, s, diretamente. Nesse caso, a estrutura switch pode apresentar a seguinte forma: switch(s) { case "1": ... case "2": ... } • Mas não se admite passar explícitamente de uma etiqueta de caso a outra, se está permitido apilhar etiquetas de caso, por exemplo: case 0: case 1: // do something;
Palavra-chave foat A palavra-chave foat denota um tipo simple que armazena valores de ponto flutuante de 32 bits. A seguinte taba mostra a precisión e ou intervalo aproximado para o tipo foat. Tipo foat
Intervalo aproximado 45
38
±1.5 × 10− a ±3.4 × 10
Precisión
Tipo do .NET Framework
7 dígitos
System.Single
Literais De forma predeterminada, um literal numérico real no lado direito do operador dassinalação se trata como double. Por consiguiente, para inicializar uma variável do tipo foat, utilize ou sufijo f ou F; por exemplo: foat x = 3.5F; Se não utiliza ou sufijo na declaração anterior, obterá um erro de compilação, já que está intentando armazenar um valor do tipo double em uma variável do tipo foat. Conversões É possível combinar tipos numéricos integral e tipos de ponto flutuante em uma expressão. Neste caso, os tipos integrais se conviertem em tipos de ponto fotante. A evaluação da expressão se realiza segundo as seguintes reglas: • Se unão de os tipos de ponto flutuante é double, a expressão se avalie como double (o bool no caso de expressões relacionales ou booleanas).
Se não existe nenhum tipo double na expressão, esta se avalie como foat (o bool no caso de expressões relacionales ou booleanas).
•
Uma expressão de ponto flutuante pode conter os seguintes conjuntos de valores: •
Cero negativo e positivo
Visual C# Consolidado
218
•
Infinito positivo e negativo
•
Valor Nam (não é um número)
•
O conjunto finito de valores distintos de cero
Para obter mais informação sobre estes valores, consulte o estándar IEEE para aritmética binaria de ponto flutante, disponivel no sitio Web http://www.ieee.org/. Exemplo No seguinte exemplo, se inclui um int, um short e um foat em uma expressão matemática que proporciona um resultado do tipo foat (observe que não existe nenhum double na expressão). // keyword_foat.cs // Mixing types in expressions using System; class MixedTypes { public static void Main() { int x = 3; foat e = 4.5f; short z = 5; Console.WriteLine("The result is {0}", x*y/z); } }
Resultados The result is 2.7
Palavra-chave params A palavra-chave params permite especificar um parâmetro de método que aceita um número variável dargumentos. Não é permitido parâmetros adicionales depois da palavra-chave params, nem varias palavraschave params em uma mesma declaração de método. Exemplo // cs_params.cs using System; public class MyClass { public static void UseParams(params int[] list) { for ( int i = 0 ; i < list.Length ; i++ ) Console.WriteLine(list[i]); Console.WriteLine(); } public static void UseParams2(params object[] list) { for ( int i = 0 ; i < list.Length ; i++ ) Console.WriteLine(list[i]); Console.WriteLine(); } public static void Main() {
Palavra-chave typeof O operador typeof é utilizado com o fim de obter ou objeto System.Type para um tipo. uma expressão typeof se apresenta da seguinte forma: t y p e o f ( type) de onde: type Tipo cujo objeto System.Type se deseja obtener. Comentarios O operador typeof não pode sobrecargar. Para obter ou tipo de uma expressão em tiempo de execução, pode utilizar o método GetType do .NET Framework. Exemplo // cs_operator_typeof.cs // Using typeof operator using System; using System.Reflection; public class MyClass { public int intI; public void MyMeth() { } public static void Main() {
Visual C# Consolidado
220
Type t = typeof(MyClass); // alternatively, you could use // MyClass t1 = new MyClass(); // Type t = t1.GetType(); MethodInfo[] x = t.GetMethods(); foreach (MethodInfo xtemp in x) { Console.WriteLine(xtemp.ToString()); } Console.WriteLine(); MemberInfo[] x2 = t.GetMembers(); foreach (MemberInfo xtemp2 in x2) { Console.WriteLine(xtemp2.ToString()); } } }
Resultado Int32 GetHashCode() Boolean Equals(System.Object) System.String ToString() Void MyMeth() Void Main() System.Type GetType() Int32 intI Int32 GetHashCode() Boolean Equals(System.Object) System.String ToString() Void MyMeth() Void Main() System.Type GetType() Void .ctor() Exemplo // cs_operator_typeof2.cs // Using GetType method using System; class GetTypeTest { public static void Main() { int radius = 3; Console.WriteLine("Area = {0}", radius*radius*Math.PI); Console.WriteLine("The type is {0}",
Visual C# Consolidado
221
(radius*radius*Math.PI).GetType()); } }
Resultado Area = 28.2743338823081 The type is System.Double
Palavra-chave try-catch A instrução try-catch consta de um bloco try seguido de uma ou mais cláusulas catch, as quais especificam controladores para diferentes exceções . Esta instrução apresenta uma das seguintes formas: t r y try-bock c a t c h ( exception-declaration-1) catch-bock-1 c a t c h ( exception-declaration-2) catch-bock-2 ... t r y try-bock c a t c h catch-bock de onde: try-bock •
Contém o segmento de código que pode produzir a exceção.
Comentarios O bloco try-bock Contém o bloco de código suceptível de causar a exceção. Este bloco se executa até que se produza uma exceção ou até completarse satisfatoriamente. Por exemplo, ou seguinte intento de converter o tipo de um objeto null provoca a exceção NullReferenceException: object o2 = null; try { int i2 = (int) o2; // Erro } A cláusula catch pode utilizar sem argumentos, em cujo caso captura qualquer tipo de exceção e se conhece como cláusula catch geral. Também pode aceitar um argumento de objeto derivado de System.Exception, em cujo caso trata uma exceção específica. Por exemplo: catch (InvalidCastException e) { } É possível utilizar mais de uma cláusula catch específica na mesma instrução try-catch. Neste caso, a ordem das cláusulas catch é importante já que estas se examinam por ordem. As exceções mais específicas se capturam antes que as menos específicas.
Visual C# Consolidado
222
Se pode utilizar uma instrução throw no bloco catch para voltar a provocar a exceção capturada pela instrução catch. Por exemplo: catch (InvalidCastException e) { throw (e); // Rethrowing exception e } Se deseja voltar a provocar a exceção que está sendo atualmente controlada por uma cláusula catch sem parâmetros, use a instrução throw sem argumentos. Por exemplo: catch { throw; } Quando estes dentro de um bloco try, inicialice só variáveis declaradas em seu interior; caso contrario, pode provocarse uma exceção antes de que se complete a execução do boque. Por exemplo, no seguinte Exemplo de código, a variável x se inicializa dentro do bloco try. Ao intentar utilizar a variável fora do bloco try, na instrução Write(x), se gerará ou seguinte erro do compilador: Uso de variável ocal não assinalada. public static void Main() { int x; try { x = 123; // Don't do that. // ... } catch { // ... } Console.Write(x); // Erro: Use of unassigned ocal variável 'x'. } Exemplo Neste exemplo, o bloco try contém uma chamada ao método MyFn(), que pode produzir uma exceção. A cláusula catch Contém o controlador da exceção, o qual simplemente mostra um mensagem na tela. Quando se realiza a chamada à instrução throw desde dentro de MyFn(), o sistema busca a instrução catch e mostra a mensagem Exception caught. // Rethrowing exceptions: using System; class MyClass { public static void Main() { MyClass x = new MyClass(); try { string s = null; x.MyFn(s); } catch (Exception e)
Visual C# Consolidado
223
{ Console.WriteLine("{0} Exception caught.", e); } } public void MyFn(string s) { if (s == null) throw(new ArgumentNullException()); } }
Resultado Se produza a exceção seguinte: System.ArgumentNullException Exemplo Neste exemplo, se utilizam dos instruções catch. A exceção mais específica, que aparece em primeiro lugar, se captura primero. // Ordering catch clauses using System; class MyClass { public static void Main() { MyClass x = new MyClass(); try { string s = null; x.MyFn(s); } // Most specific: catch (ArgumentNullException e) { Console.WriteLine("{0} First exception caught.", e); } // Least specific: catch (Exception e) { Console.WriteLine("{0} Second exception caught.", e); } } public void MyFn(string s) { if (s == null) throw new ArgumentNullException(); } }
Resultado Se produza a exceção seguinte:
Visual C# Consolidado
224
System.ArgumentNullException No Exemplo anterior, se empieza com a cláusula catch menos específica, se obterá o mensagem: A previous catch clause already catches all exceptions of this or a super type ('System.Exception') Não obstante, para capturar a exceção menos específica, deve substituir a instrução throw pela seguinte: throw new Exception();
Palavra-chave for O laço for executa uma instrução ou um bloco de instruções repetidamente até que uma expressão especificada se avalie como false. Apresenta a seguinte forma: f o r ( [initializers]; [expression]; [iterators]) statement de onde: initializers • Lista de expressões ou instruções dassinalação, separadas por comas, que inicializam os contadores do laço. expression Expressão que pode converterse implícitamente no tipo bool ou em um tipo que contenga a sobrecarga de os operadores true e false. A expressão se usa para comprovar ou criterio de terminação do laço. iterators •
Expressões ou instruções que incrementan ou reducem os contadores do laço.
statement •
Instruções que se devem executar dentro do laço.
Comentarios A instrução for executa sus instruções internas repetidamente da seguinte forma: •
Primero, avalie os inicializadores.
A continuação, enquanto expression se avalie como true, se executan as instruções do laço e se avalien os iteradores.
• •
Quando expression se faz false, o controle se transfere fora do laço.
Debido a que a comprobação de expression tem lugar antes da execução do laço, a instrução for se executa cero ou varias veces. Todas as expressões da instrução for são opcionales; por exemplo, a seguinte instrução é utilizado para criar um laço infinito: for (;;) { ... } Exemplo // statements_for.cs // for oop using System; public class ForOopTest { public static void Main()
Visual C# Consolidado
225
{ for (int i = 1; i <= 5; i++) Console.WriteLine(i); } }
Resultado 1 2 3 4 5
Palavra-chave private A palavra-chave private é um modificador de acesso de membros. ou acesso do tipo private corresponde ao nivo de acesso mais restrictivo. Os membros privados só são accesibles dentro do corpo da classe o a estrutura na qual se declaran. Os tipos anidados do mesmo corpo também podem ter acesso a esses membros privados. Fazer referencia a um membro privado fora da classe o estrutura na que se declara produza um erro de compilação. Encontrará uma comparação de private com os outros modificadores de acesso em Niveles daccesibilidad. Exemplo Neste exemplo, a classe Empoyee contém um membro público, Name, e um membro privado, Salary. ou acesso ao membro público pode realizar diretamente, enquanto que o acesso ao membro privado deve fazerse a través do método público AccessSalary(). // private_keyword.cs using System; class Empoyee { public string name = "xx"; double salary = 100.00; // private access by default public double AccessSalary() { return salary; } } class MainClass { public static void Main() { Empoyee e = new Empoyee(); // Accessing the public field: string n = e.name; // Accessing the private field: double s = e.AccessSalary(); }
Visual C# Consolidado
226
} No Exemplo anterior, se intenta obter acesso diretamente a os membros privados mediante uma instrução como a seguinte: double s = e.salary; obterá o seguinte mensagem de erro: 'Empoyee.Salary' is inaccessible due to its protection level.
Palavra-chave uint A palavra-chave uint denota um tipo integral que armazena valores segundo ou tamanho e ou intervo que se indicam na taba seguinte. Tipo
Intervalo
Tamanho
Tipo do .NET Framework
uint
0 a 4.294.967.295
Inteiro de 32 bits sem signo
System.UInt32
Literais As variáveis do tipo uint podem se declarar e inicializar como no seguinte exemplo: uint myUint = 4294967290; Quando um literal inteiro não tem sufijo, seu tipo é ou primero de estes tipos no que pode representar seu valor: int, uint, ong, uong. Neste exemplo, é uint. Também pode utilizar o sufijo u ou U: uint myUint = 123U; Quando é utilizado ou sufijo U ou u, ou tipo do literal será uint ou uong, segundo seu tamanho. Neste exemplo, é uint. Conversões Existe uma conversão implícita predefinida de uint a ong, uong, foat, double ou decimal. Por exemplo: foat myFoat = 4294967290; // OK: implicit conversion to foat Existe uma conversão implícita predefinida de byte, ushort ou char a uint. Em qualquer outro caso, deve utilizar uma conversão explícita. Por exemplo, para uma variável do tipo ong, myOng, a seguinte instrução dassinalação produzirá um erro de compilação sem uma conversão explícita: ong myOng = 22; uint myUint = myOng; // Erro: não implicit conversion from ong uint myUint = (uint)myOng; // OK: explicit conversion Observe que tampoco existe conversão implícita de tipos de ponto flutuante a uint. Por exemplo, a instrução seguinte gerará um erro de compilação, a menos que se utilize uma conversão explícita: uint x = 3.0; // Erro: não implicit conversion from double uint e = (uint)3.0; // OK: explicit conversion Para obter mais informação sobre expressões aritméticas com tipos de ponto flutuante e tipos integrais, veja foat e double. Para obter mais informação sobre as regas de conversão numérica implícitas, veja a Taba de conversões numéricas implícitas.
Visual C# Consolidado
227
PALAVRA-CHAVE CHAR A palavra-chave char é utilizado para declarar um carácter Unicode no intervalo indicado na seguinte tabla. Os caracteres Unicode são caracteres de 16 bits que se utilizam para representar a maioría de os lenguajes escritos de todo ou mundo.
Tipo
Intervalo
Tamanho
Tipo do .NET Framework
char
U+0000 a U+ffff
Carácter Unicode de 16 bits
System.Char
Literais As constantes do tipo char podem se escrever como caracteres literais, secuencias de escape hexadecimales ou representações Unicode. Os códigos de caracteres integrais podem se converter explícitamente ao tipo char. Em as seguintes instruções se declara uma variável do tipo char e se inicializa com o carácter X: char MyChar = 'X'; // Character literal char MyChar = '\x0058'; // Hexadecimal char MyChar = (char)88; // Cast from integral type char MyChar = '\u0058'; // Unicode Conversões Um valor do tipo char pode converter implícitamente a os tipos ushort, int, uint, ong, uong, foat, double ou decimal. Sem embargo, não existem conversões implícitas desde outros tipo ao tipo char.
Palavra-chave foreach, in A instrução foreach repite um grupo de instruções incluidas no laço para cada elemento de uma matriz ou de um objeto collection. A instrução foreach é utilizado para iterar em uma coleção de elementos e obter a informação desejada, pois não deve utilizar para cambiar ou contenido da colecção, já que podem se produzir efectos secundarios imprevisibles. A instrução apresenta a seguinte forma: f o r e a c h ( type identifier i n expression) statement de onde: type Tipo do identificador identifier. identifier • Variável de iteração que reapresenta ou elemento da colecção. Se a variável de iteração é um tipo de valor, se trata em efeito de uma variável de só lectura que não pode ser modificada. expression Expressão que reapresenta uma matriz ou uma coleção de objetos. ou tipo de os elementos da coleção deve poder converterse ao tipo de identifier. Não utilize uma expressão que evalúe como null. Evalúe um tipo que implemente IEnumerable ou um tipo que declare um método GetEnumerator. no último caso, GetEnumerator deve devoltar um tipo que implemente IEnumerator ou que declare todos os métodos definidos em IEnumerator statement
Visual C# Consolidado
228
•
Instruções que se devem executar dentro do laço.
Comentarios As instruções do laço seguem executándose para cada elemento da matriz ou a colecção. Quando já se han recorrido todos os elementos da colecção, o controle se transfere à seguinte instrução fora do bloco foreach. Para obter mais informação acerca da palavra-chave foreach, incluidos exemplos de código, veja os temas seguintes: •
Usar foreach com arrays
•
Usar foreach com coleções
Palavra-chave volatile A palavra-chave volatile indica que um campo pode ser modificado no programa pelo sistema operativo, ou hardware ou um subproceso em execução de forma simultánea. v o l a t i l e declaration de onde: declaration •
A declaração de um campo.
Comentarios O sistema siempre lee o valor atual de um objeto volátil no ponto de onde se solicita, aum quando a instrução previa pidiera um valor ao mesmo objeto. Assim mesmo, o valor de um objeto se escreve inmediatamente no momento da assinalação. O modificador volatile se suele utilizar para um campo ao que tengan acesso varios subprocesses sem utilizar a instrução ock para serializar ou acesso . O uso do modificador volatile garante que um subproceso recupere o valor mais atualizado de os escritos por outro subproceso. O tipo de um campo marcado como volátil está restringido a os seguintes tipos: •
Qualquer tipo de referencia.
•
Qualquer tipo de ponteiro (em um contexto não seguro).
•
Os tipos byte, sbyte, short, ushort, int, uint, char, foat ou bool.
•
Um tipo enum com um tipo base enum de byte, sbyte, short, ushort, int ou uint.
Para obter mais informação sobre o modificador volatile, veja 10.4.3 Campos volátiles. Exemplo O Exemplo seguinte mostra como declarar uma variável de campo pública como volatile. // csharp_volatile.cs class Test { public volatile int i; Test(int _i) { i = _i; } public static void Main() {
Visual C# Consolidado
229
} }
Palavra-chave delegate Uma declaração delegate define um tipo de referencia que pode utilizar para encapsular um método com uma firma específica. uma instancia de delegado encapsua um método estático ou de instancia. Os delegados são similares a os ponteiros a funções de C++, pois são mais seguros e proporcionam maior seguridad de tipos. A declaração apresenta a seguinte forma: [attributes] [modifiers] d e l e g a t e result-type identifier ( [formal-parameters]) ; de onde: attributes (opcional) Informação declarativa adicional. Para obter mais informação sobre os atributos e as classes datributo, veja 17. Atributos. modifiers (opcional) Os modificadores permitidos são new e os cuatro modificadores de acesso . result-type •
Tipo do resultado, que coincide com o tipo devuelto do método.
identifier •
Mome do delegado.
formal-parameters (opcional) Lista de parâmetros. Se um parâmetro é um ponteiro, ou delegado deve declararse com o modificador unsafe. Comentarios Um delegado permite passar uma função como parâmetro. A seguridad de tipos de os delegados requiere que a função que se pasa como delegado tenga a mesma firma que a declaração do delegado. Veja ou Tutorial de delegados para obter mais informação sobre o uso de delegados. O Tutorial de delegados mostra como componer delegados, assim, criar delegados a partir de outros delegados. um delegado que contém um parâmetro out não pode componer. Os delegados são a base de os eventos. Para obter mais informação sobre delegados, veja 15. Delegados. Exemplo 1 O seguinte é um Exemplo sencilo de declaração e uso de um delegado. // keyword_delegate.cs // delegate declaration delegate void MyDelegate(int i); class Program { public static void Main() { TakesADelegate(new MyDelegate(DelegateFunction)); } public static void TakesADelegate(MyDelegate SomeFunction) {
Visual C# Consolidado
230
SomeFunction(21); } public static void DelegateFunction(int i) { System.Console.WriteLine("Called by delegate with number: {0}.", i); } }
Resultados Called by delegate with number: 21. Exemplo 2 no seguinte exemplo, um delegado se assinala os métodos estáticos e de instancia e devolve informação específica de cada unão de elos. // keyword_delegate2.cs // Calling both static and instance methods from delegates using System; // delegate declaration delegate void MyDelegate(); public class MyClass { public void InstanceMethod() { Console.WriteLine("A message from the instance method."); } static public void StaticMethod() { Console.WriteLine("A message from the static method."); } } public class MainClass { static public void Main() { MyClass p = new MyClass(); // Map the delegate to the instance method: MyDelegate d = new MyDelegate(p.InstanceMethod); d(); // Map to the static method: d = new MyDelegate(MyClass.StaticMethod); d(); } }
Resultados A message from the instance method. A message from the static method.
Visual C# Consolidado
231
Palavra-chave ock A palavra-chave ock marca um bloco de instruções como uma seção crucial, para o que utiliza ou boqueo de exclusión mutua de um objeto, a execução de uma instrução y, posteriormente, a liberação do boqueo. A instrução apresenta a seguinte forma: o c k ( expression) statement_bock de onde: expression Especifica ou objeto sobre ou que se deseja aplicar a instrução ock. Expression deve ser um tipo de referencia. Normalmente, expression será this, se se deseja proteger uma variável de instancia, ou biem typeof(classe), se se deseja proteger uma variável do tipo static (o se a seção crítica se encontra em um método estático da classe dada). statement_bock •
Instruções da seção crítica.
Comentarios A instrução ock permite garantizar que um subproceso não va a entrar em uma seção crítica de código enquanto outro subproceso já se encontra em ella. Se outro subproceso intenta entrar em um código boqueado, esperará até que o objeto se libere. Exemplo 1 O seguinte Exemplo mostra um uso simple de subprocesses em C#. // statements_ock.cs using System; using System.Threading; class ThreadTest { public void runme() { Console.WriteLine("runme called"); } public static void Main() { ThreadTest b = new ThreadTest(); Thread t = new Thread(new ThreadStart(b.runme)); t.Start(); } }
Resultado runme called Exemplo 2 O seguinte Exemplo usa subprocesses e ock. Enquanto a instrução ock está presente, o bloco de instruções constituye uma seção crítica e balance nunca se converterá em um número negativo. // statements_ock2.cs using System;
Visual C# Consolidado
232
using System.Threading; class Account { int balance; Random r = new Random(); public Account(int initial) { balance = initial; } int Withdraw(int amount) { // This condition will never be true unless the ock statement // is commented out: if (balance < 0) { throw new Exception("Negative Balance"); } // Comment out the next line to see the effect of leaving out // the ock keyword: ock (this) { if (balance >= amount) { Console.WriteLine("Balance before Withdrawal :" +balance); Console.WriteLine("Amount to Withdraw :-"+ amount); balance = balance - amount; Console.WriteLine("Balance after Withdrawal : " + balance); return amount; } else { return 0; // transaction rejected } } } public void DoTransactions() { for (int i = 0; i < 100; i++) { Withdraw(r.Next(1, 100)); } } } class Test { public static void Main() { Thread[] threads = new Thread[10]; Account acc = new Account (1000); for (int i = 0; i < 10; i++) { Thread t = new Thread(new ThreadStart(acc.DoTransactions));
Visual C# Consolidado
233
threads[i] = t; } for (int i = 0; i < 10; i++) { threads[i].Start(); } } }
Palavra-chave stackaloc Permite assinalar um bloco de memoria na pilba. type * ptr = s t a c k a l o c type [ expr ] ; de onde: type •
Tipo não administrado.
ptr •
Mome de ponteiro.
expr •
Expressão entera.
Comentarios Se reserva na pia um bloco de memoria de tamanho suficiente para conter expr elementos do tipo type; a direção do bloco se armazena no ponteiro ptr. Esta memoria não está sometida a reciclaje y, por o tanto, não necessita fijarse (por medio de fixed). A vida do bloco de memoria se limita à vida do método no que se define. O operador stackaloc só é válido em inicializadores de variáveis ocales. Como se utilizam ponteiros (ver A.2 Tipos de ponteiro), stackaloc requiere um contexto unsafe. O operador stackaloc é similar a _aloca da biblioteca de tiempo de execução de C. Exemplo // cs_keyword_stackaloc.cs // compile with: /unsafe using System; class Test { public static unsafe void Main() { int* fib = stackaloc int[100]; int* p = fib; *p++ = *p++ = 1; for (int i=2; i<100; ++i, ++p) *p = p[-1] + p[-2]; for (int i=0; i<10; ++i) Console.WriteLine (fib[i]); } }
Resultado 1
Visual C# Consolidado
234
1 2 3 5 8 13 21 34 55
Visual C# Consolidado
235
Visual C# Consolidado
236
OPERADORES C# C# fornece um conjunto grande de operadores, que são símbolos que especificam as operações para executar em uma expressão. C# predefines os operadores aritméticos e lógicos normal, bem como uma variedade de outras pessoas como mostrado na tabela a seguir. Operações em integral tipos, como ==, !=, <, >, <=, >=, binary +, binary -, ^, &, |, ~, ++, --,. e sizeof() geralmente são permitidos em enumerações Além disso, vários operadores podem ser Sobrecarregado pelo usuário, assim alterando seu significado quando aplicado a um tipo definido pelo usuário. Categoria de operadores
Operadores
Aritmética
+ - * / %
Lógico (boolean e bit a bit)
& | ^ ! ~ && || True False
Concatenação de seqüência de caracteres
+
Incremento, decrement
++ --
SHIFT
<< >>
Relacional
== != < > <= >=
Atribuição
= += -= *= /= %= &= |= ^= <<= >>= ??
Acesso membro
.
Indexação
[]
Conversão
()
Condicional
?:
Concatenação representante e remoção
+ -
A criação do objeto
Novo
Informações de Tipo
Como é sizeof TypeOf
Estouro Controle de exceção
Marcada desmarcada
Indirection e endereço
* -> [] &
Estouro Aritmético Os operadores aritméticos (+., -) pode produzir resultados que estejam fora do intervalo dos valores possíveis para o tipo numérico envolvido, /* Você deve consultar a seção sobre um operador específico para obter detalhes, mas em geral: •
Qualquer throws estouro aritmético inteiro ou descarta os bits do resultado mais significativos. um OverflowException Divisão por zero sempre throws um DivideByZeroException.
•
Ponto flutuante estouro aritmético ou divisão por zero nunca gera uma exceção, como tipos de ponto flutuante estão baseados em IEEE 754 and caso tenha disposições para representar infinito e NaN (Not a Number).
•
Estouro Aritmético Decimal Sempre gera um OverflowException. Decimal divisão por zero sempre throws um DivideByZeroException. Quando estouro inteiro ocorre, o que acontece depende do contexto de execução, que pode ser marcado ou desmarcado. Em um contexto selecionado, será gerada. um OverflowException Em um contexto desmarcado, os bits do resultado mais significativos são descartados e continua a execução. Assim, C# oferece a você a opção de manipulação ou ignorando estouro.
Visual C# Consolidado
237
Os operadores aritméticos, além de tipo integral-tipo para integral-casts podem causar estouro, por exemplo, Projetando e estão sujeitas às execução marcado ou desmarcado. para um Longo An Int, Entretanto, operadores bit a bit e operadores SHIFT nunca causar estouro.
Transbordamento aritmético Os operadores aritméticos (+, -, *, /) podem produzir resultados fora do intervalo de valores possíveis para o tipo numérico implicado. Pode encontrar mais informação acerca de um determinado operador na seção Referença do lenguaje C#; não obstante, em general: • O transbordamento aritmético de inteiros inicia uma exceção de transbordamento (OverflowExcetion) o bem elimina os bits mais significativos do resultado (véase mais abaixo). a divisão de inteiros por cero sempre produz uma exceção DivideByZeroExcetion. • O transbordamento aritmético ou a divisão por cero em ponto flutuante não produzem uma exceção, já que os tipos de ponto flutuante se baseiam em o estándar IEEE 754, que proporciona uma representação para os valores infinito e Nam (Not a Number, no é um número). • O transbordamento aritmético de valores do tipo decimal sempre produz uma exceção
OverflowExcetion. a divisão de valores decimal por zero sempre produz uma exceção DivideByZeroExcetion. Quando é produzido um transbordamento de inteiros, lo que ocurre depende do contexto da execução, o qual pode ser checkede o unchecked. em um contexto checkede (comprobado), é produzido uma exceção OverflowExcetion. em um contexto uncheckede (no comprobado), os bits mais significativos do resultado não se temm em cuenta e a execução continúa. Desta forma, C# permite escolher entre atender o desatender o transbordamento. Além dos operadores aritméticos, as conversões explícitas entre tipos integrais também podem produzir transbordamento (por exemplo, converter um tipo long em um tipo int) e estão sometidas ao tipo de execução checkede o unchecked. Por otro lado, observe que os operadores de deslocamento e de bit a bit nunca produzem transbordamento.
Operadores sobrecarregados C# permite sobrecarregar operadores nos tipos definidos pelo usuario, mediante a definição, com a palavra chave operator, de funções membro estáticas. Não obstante, no todos os operadores podem ser sobrecarregados, e alguns apresentam restricções, como se indica na seguinte tabela: Operadores
Posibilidade de sobrecarrega
+, -, !, ~, ++, --, true, false
Estes operadores unários podem ser sobrecarregados.
+, -, *, /, %, &, |, ^, <<, >>
Estes operadores binários podem ser sobrecarregados.
Visual C# Consolidado
238
==, !=, <, >, <=, >=
Os operadores de comparação podem ser sobrecarregados (veja a nota mais abaixo).
&&, ||
Os operadores lógicos não podem ser cargar, mas se avaliam com & e |, que podem sobrecarregarse. Veja 7.11.2 Operadores lógicos condicionais definidos pelo usuario.
[]
O operador de indicação de arrays não pode sobrecarregar, mas podem ser definido indicadores.
()
O operador de conversão explícita do tipos não pode sobrecarregar, mas podem ser definido novos operadores de conversão (veja explicit e implicit).
+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
Os operadores de assinalação não podem ser sobrecarregados, mas +=, por exemplo, se avalia com +, o qual se pode sobrecarregar.
=, ., ?:, ->, new, is, sizeof, typeof
Estes operadores não podem ser sobrecarregados.
Nota os operadores de comparação, se sobrecarregam, devem ser por parejas; é dizer, se sobrecarrega ==, também deve sobrecarregar !=. Também é cierta a opção contraria, análogamente para o caso de < e >, e para <= e >=.
Operador [ ] Os colchetes ([ ]) são utilizados para arrays, indicadores e atributos. Também podem ser utilizar com ponteiros. type [ ] array [ indexexpr ] De onde: type Tipo. array Array. indexexpr Expressão de índice. Comentarios Um tipo de array é composto de um tipo seguido de []: int[] fib; // fib is of type int[], "array of int" fib = new int[100]; // criate a 100-element int array Para obter acesso a um elemento do array, o índice do elemento desejado se encierra entre colchetes: fib[0] = fib[1] = 1; for( int i=2; i<100; ++i ) fib[i] = fib[i-1] + fib[i-2]; É produzido uma exceção se o índice do array está fora do intervalo declarado. O operador de indicação não pode sobrecarregar; não obstante, os tipos podem definir indicadores, que são propriedades que aceitam um ou varios parâmetros. Os parâmetros de um
Visual C# Consolidado
239
indicador ficam entre colchetes, como os índices de um array, mas podem ser declarar de qualquer tipo (a diferença dos índices de um array, que somente podem ser integrais). Por exemplo, .NET Framework define um tipo Hashtable que asoça chaves e valores do tipo arbitrario: Collections.Hashtable h = new Collections.Hashtable(); h["a"] = 123; // note: using a string as the index Os colchetes também são utilizados para especificar atributos: [attribute(AllowMultiple=true)] public class Attr { } Podem ser utilizados colchetes para obter o valor que aponta um ponteiro segundo um índice (veja A.2 Tipos de ponteiros): unsafe fixede ( int* p = fib ) // p points to fib from earlier example { p[0] = p[1] = 1; for( int i=2; i<100; ++i ) p[i] = p[i-1] + p[i-2]; } Não obstante, tenga em cuenta que não se realiza uma comprobação dos límites do índice.
Operador ( ) Além disso de seu uso para especificar o ordem de as operações em uma expressão, os paréntesis são utilizados para especificar conversões do tipo explícitas (cast): ( type ) expr De onde: type Nome do tipo o que se deseja converter a expressão expr. expr Expressão. Comentarios Uma conversão do tipo invoca explícitamente ao operador de conversão para converter o tipo da expressão expr ao tipo type; será produzido um erro na conversão se não se tenha definido esse operador. Para definir um operador de conversão, veja explicit e implicit. Exemplo O seguinte programa converte explícitamente um tipo double em um tipo int. O programa não compilará sem o operador de conversão do tipo. // cs_operator_parentheses.cs using System; class Test { public static void Main() { double x = 1234.7; int a; a = (int)x; // cast double to int Console.WriteLine(a);
Visual C# Consolidado
240
} }
Resultado 1234
Operador . (ponto) O operador de ponto é utilizado para o acesso a membros. name1 . name2 De onde: name1 Nome. name2 Nome. Comentarios Por exemplo, considere a seguinte clase: class Simple { public int a; public void b() { } } Simple s = new Simple(); A variáveis tem dos membros, a e b; para tener acesso a ellos, use o operador de ponto: s.a = 6; // assign to field a; s.b(); // invoke member function b; O ponto também é utilizado para formar nomes completos, é dizer, nomes que especificam o namespaces ou a interfaz (por exemplo) à que pertencem. System.Console.WriteLine("hello"); // class Console in namespace System A directiva using hace que a calificação de nomes seja opcional em alguns casos: using System; ... System.Console.WriteLine("hello"); Console.WriteLine("hello"); // same thing Mas, um identificador ambiguo deve calificarse: using System; using OtherSystem; // a namespace containing another Console class ... System.Console.WriteLine( "hello" ); // must qualify Console
Operador + O operador + pode funcionar como operador unário o binário.
Visual C# Consolidado
241
+ expr expr1 + expr2 De onde: expr Expressão. expr1 Expressão. expr2 Expressão. Comentarios Os operadores + unários se encontram predefinidos para todos os tipos numéricos. O resultado de uma operação + unaria aplicada a um tipo numérico é simplemente o valor do operando. Os operadores + binários estão predefinidos para os tipos numéricos e de cadena de caracteres. Para tipos numéricos, + calcula a suma de seus dos operandos. Quando ao menos um dos operandos é do tipo string, + concatena as representações do tipo string dos operandos. Os tipos delegados também proporcionam um operador binário +, o qual realiza a concatenação de delegados. Os tipos definidos pelo usuario podem sobrecarregar os operadores + unário e binário (veja operator). Exemplo // cs_operator_plus.cs using System; class Test { public static void Main() { Console.WriteLine(+5); // unary plus Console.WriteLine(5 + 5); // addition Console.WriteLine(5 + .5); // addition Console.WriteLine("5" + "5"); // string concatenation Console.WriteLine(5.0 + "5"); // string concatenation // note automatic conversion from double to string } }
Resultado 5 10 5.5 55 55
Operador O operador - pode funcionar como operador unário o binário. - expr
Visual C# Consolidado
242
expr1 - expr2 De onde: expr Expressão. expr1 Expressão. expr2 Expressão. Comentarios Os operadores - unários se encontram predefinidos para todos os tipos numéricos. O resultado de uma operação - unaria aplicada a um tipo numérico é a negação do operando. Os operadores – binários estão predefinidos para todos os tipos numéricos e de enumeração de modo que restam o segundo operando do primeiro. Os tipos delegados também proporcionam um operador - binário, o qual realiza a eliminação de delegados. Os tipos definidos pelo usuario podem sobrecarregar os operadores - unário e binário (veja operator). Exemplo // cs_operator_minus.cs using System; class Test { public static void Main() { int a = 5; Console.WriteLine(-a); Console.WriteLine(a - 1); Console.WriteLine(a - .5); } }
Resultado -5 4 4.5
Operador * O operador de multiplicação (*) calcula o produto de seus operandos. Todos os tipos numéricos possuem operadores de multiplicação predefinidos. expr1 * expr2 De onde: expr1 Expressão. expr2
Visual C# Consolidado
243
Expressão. Comentarios O operador * também é utilizado para declarar tipos de ponteiros e para desfazer a referença a ponteiros (veja A.2 Tipos de ponteiros). Os tipos definidos pelo usuario podem sobrecarregar o operador * (veja operator). Exemplo // cs_operator_mult.cs using System; class Test { public static void Main() { Console.WriteLine(5 * 2); Console.WriteLine(-.5 * .2); Console.WriteLine(-.5m * .2m); // decimal type } }
Resultado 10 -0.1 -0.10
Operador / O operador de divisão (/) permite dividir seu primeiro operando pelo segundo. Todos os tipos numéricos possuem operadores de divisão predefinidos. expr1 / expr2 De onde: expr1 Expressão. expr2 Expressão. Comentarios Os tipos definidos pelo usuario podem sobrecarregar o operador / (veja operator). Exemplo // cs_operator_division.cs using System; class Test { public static void Main() { Console.WriteLine(-5/2); Console.WriteLine(-5.0/2); } }
Visual C# Consolidado
244
Resultado -2 -2.5
Operador % O operador de módulo (%) calcula o resto de dividir seu primeiro operando pelo segundo. Todos os tipos numéricos possuem operadores de módulo predefinidos. expr1 % expr2 De onde: expr1 Expressão. expr2 Expressão. Comentarios Os tipos definidos pelo usuario podem sobrecarregar o operador % (veja operator). Exemplo // cs_operator_modulus.cs using System; class Test { public static void Main() { Console.WriteLine(5 % 2); // int Console.WriteLine(-5 % 2); // int Console.WriteLine(5.0 % 2.2); // double Console.WriteLine(5.0m % 2.2m); // decimal Console.WriteLine(-5.2 % 2.0); // double } }
Resultado 1 -1 0.6 0.6 -1.2 Observe os erros de rede onde o que apresenta o tipo double.
Operador & O operador & pode funcionar como operador unário o binário. & expr expr1 & expr2 De onde: expr
Visual C# Consolidado
245
Expressão. expr1 Expressão. expr2 Expressão. Comentarios O operador & unário devolve a direção de memoria de seu operando (requiere um contexto unsafe). Os operadores & binários estão predefinidos para os tipos integrais e bool. Para tipos integrais, & calcula a operação AND bit a bit de seus operandos. Para operandos do tipo bool, & calcula a operação lógica AND de seus operandos; é dizer, o resultado é true se, e somente se, ambos operandos são true. Os tipos definidos pelo usuario podem sobrecarregar o operador & binário (veja operator). Exemplo // cs_operator_ampersand.cs using System; class Test { public static void Main() { Console.WriteLine(true & false); // logical and Console.WriteLine(true & true); // logical and Console.WriteLine("0x{0:x}", 0xf8 & 0x3f); // bitwise and } }
Resultado False True 0x38
Operador | Os operadores binários | estão predefinidos para os tipos integrais e bool. Para tipos integrais, | calcula a operação OR bit a bit de seus operandos. Para operandos do tipo bool, | calcula a operação lógica OR de seus operandos; é dizer, o resultado é false se, e somente se, ambos operandos são false. expr1 | expr2 De onde: expr1 Expressão. expr2 Expressão. Comentarios Os tipos definidos pelo usuario podem sobrecarregar o operador | (veja operator).
Visual C# Consolidado
246
Exemplo // cs_operator_OR.cs using System; class Test { public static void Main() { Console.WriteLine(true | false); // logical or Console.WriteLine(false | false); // logical or Console.WriteLine("0x{0:x}", 0xf8 | 0x3f); // bitwise or } }
Resultado True False 0xff
Operador ^ Os operadores ^ binários estão predefinidos para os tipos integrais e bool. Para tipos integrais, ^ calcula a operação OR exclusiva bit a bit de seus operandos. Para operandos do tipo bool, ^ calcula a operação lógica OR exclusiva de seus operandos; é dizer, o resultado é true se, e somente se, exatamente um dos operandos é true. expr1 ^ expr2 De onde: expr1 Expressão. expr2 Expressão. Comentarios Os tipos definidos pelo usuario podem sobrecarregar o operador ^ (veja operator). Exemplo // cs_operator_bitwise_OR.cs using System; class Test { public static void Main() { Console.WriteLine(true ^ false); // logical exclusive-or Console.WriteLine(false ^ false); // logical exclusive-or Console.WriteLine("0x{0:x}", 0xf8 ^ 0x3f); // bitwise exclusive-or } }
Resultado True False
Visual C# Consolidado
247
0xc7
Operador ! O operador lógico negação (!) é um operador unário que nega seu operando. Está definido para o tipo bool, e devolve true se, e somente se, seu operando é false. ! expr De onde: expr Expressão. Comentarios Os tipos definidos pelo usuario podem sobrecarregar o operador ! (veja operator). Exemplo // cs_operator_negation.cs using System; class Test { public static void Main() { Console.WriteLine(!true); Console.WriteLine(!false); } }
Resultado False True
Operador ~ O operador ~ realiza uma operação de complemento bit a bit sobre seu operando. Os operadores de complemento bit a bit estão predefinidos para int, uint, long e ulong. ~ expr De onde: expr Expressão. Comentarios Os tipos definidos pelo usuario podem sobrecarregar o operador ~ (veja operator). Exemplo // cs_operator_bitwise_compl.cs using System; class Test { public static void Main() {
Operador = O operador de assinalação (=) armazena o valor do operando situado a seu direita na colocação de armazenamento, propriedade ou indicador indicado pelo operando situado a seu esquerda, e devolve o valor como resultado. Os operandos devem ser do mesmo tipo (o o operando da direita deve poder converter implícitamente ao tipo do operando da esquerda). lhs = expr De onde: lhs Uma colocação de armazenamento, uma propriedade ou um indicador. expr Expressão. Comentarios O operador de assinalação não pode sobrecarregar. Exemplo // cs_operator_assignment.cs using System; class Test { public static void Main() { double x; int i; i = 5; // int to int assignment x = i; // implicit conversion from int to double i = (int)x; // needs cast Console.WriteLine("i is {0}, x is {1}", i, x); object obj = i; Console.WriteLine("boxede value = {0}, type is {1}", obj, obj.GetType()); i = (int)obj; Console.WriteLine("unboxed: {0}", i); } }
Resultado i is 5, x is 5 boxede value = 5, type is System.Int32 unboxed: 5
Visual C# Consolidado
249
Operador < Todos os tipos numéricos e de enumeração definem um operador relacional "menor que" (<) que devolve true se o primeiro operando é menor que o segundo, e false em caso contrario. expr1 < expr2 De onde: expr1 Expressão. expr2 Expressão. Comentarios Os tipos definidos pelo usuario podem sobrecarregar o operador < (veja operator). se sobrecarrega <, também deve sobrecarregar >. Exemplo // cs_operator_less_than.cs using System; class Test { public static void Main() { Console.WriteLine(1 < 1.1); Console.WriteLine(1.1 < 1.1); } }
Resultado True False
Operador > Todos os tipos numéricos e de enumeração definem um operador relacional "maior que" (>) que devolve true se o primeiro operando é maior que o segundo, e false em caso contrario. expr1 > expr2 De onde: expr1 Expressão. expr2 Expressão. Comentarios Os tipos definidos pelo usuario podem sobrecarregar o operador > (veja operator). se sobrecarrega >, também deve sobrecarregar <. Exemplo // cs_operator_greater_than.cs
Visual C# Consolidado
250
using System; class Test { public static void Main() { Console.WriteLine(1.1 > 1); Console.WriteLine(1.1 > 1.1); } }
Resultado True False
Operador ?: O operador condicional (?:) devolve um de dois valores segundo o valor de uma expressão booleana. O operador condicional é utilizado em expressões da forma: cond-expr ? expr1 : expr2 De onde: cond-expr Expressão do tipo bool. expr1 Expressão. expr2 Expressão. Comentarios Si cond-expr é true, expr1 se avalia e se devolve como resultado; se cond-expr é false, é expr2 a que se avalia e se devolve como resultado. Somente uma de as dos, expr1 o expr2, resulta evaluada. Os cálculos que, em qualquer otro caso, podrían requerir um bloque de decisão if-elpodem ser expresar mais concisa e elegantemente mediante o operador condicional. Por exemplo, para evitar uma divisão por cero em o cálculo da função sinc, podría escreverse: if(x != 0.0) s = Math.Sin(x)/x; else s = 1.0; o bien, com o operador condicional, s = x != 0.0 ? Math.Sin(x)/x : 1.0; O operador condicional é asociativo por a direita, de modo que uma expressão da forma: a ? b : c ? de : e se avalia como a ? b : (c ? de : e) en lugar de (a ? b : c) ? de : e
Visual C# Consolidado
251
O operador condicional não pode sobrecarregar. Exemplo // cs_operator_condicional.cs using System; class Test { public static double sinc(double x) { return x != 0.0 ? Math.Sin(x)/x : 1.0; } public static void Main() { Console.WriteLine(sinc(0.2)); Console.WriteLine(sinc(0.1)); Console.WriteLine(sinc(0.0)); } }
Resultado 0.993346653975306 0.998334166468282 1
Operador ++ O operador de incremento (++) incrementa seu operando em 1. Este operador pode aparecer antes o depois de seu operando: + + var var + + De onde: var Expressão que indica uma colocação de armazenamento, uma propriedade ou um indicador. Comentarios A primeira forma é uma operação de incremento prefixo. O resultado da operação é o valor do operando depois de haver sido incrementado. A segunda forma é uma operação de incremento postfijo. O resultado da operação é o valor do operando antes de haver sido incrementado. Os tipos numéricos e de enumeração possuem operadores de incremento predefinidos. Os tipos definidos pelo usuario podem sobrecarregar o operador ++ (veja operator). Exemplo // cs_operator_increment.cs using System; class Test { public static void Main() { double x;
Visual C# Consolidado
252
x = 1.5; Console.WriteLine(++x); x = 1.5; Console.WriteLine(x++); Console.WriteLine(x); } }
Resultado 2.5 1.5 2.5
Operador -O operador de decremento (--) reduz seu operando em 1. Este operador pode aparecer antes o depois de seu operando: - - var var - De onde: var Expressão que indica uma colocação de armazenamento, uma propriedade ou um indicador. Comentarios A primeira forma é uma operação de decremento prefixo. O resultado da operação é o valor do operando depois de haver experimentado o decremento. A segunda forma é uma operação de decremento postfijo. O resultado da operação é o valor do operando antes de haver experimentado o decremento. Os tipos numéricos e de enumeração possuem operadores de decremento predefinidos. Os tipos definidos pelo usuario podem sobrecarregar o operador -- (veja operator). Exemplo // cs_operator_decrement.cs using System; class Test { public static void Main() { double x; x = 1.5; Console.WriteLine(--x); x = 1.5; Console.WriteLine(x--); Console.WriteLine(x); } }
Visual C# Consolidado
253
Resultado 0.5 1.5 0.5
Operador && O operador AND condicional (&&) realiza uma operação lógica AND de seus operandos do tipo bool mas somente avalia seu segundo operando se é necessário. expr1 & & expr2 De onde: expr1 Expressão. expr2 Expressão. Comentarios A operação x && y corresponde com a operação x&y salvo que se x é false, e não se avalia (já que o resultado da operação AND será false independentemente do valor de y). Este se conhece como evaluação "cortocircuitada". O operador AND condicional não pode sobrecarregar, mas as sobrecarregas dos operadores lógicos normales e os operadores true e false se consideran tambem, com ciertas restricções, sobrecarregas dos operadores lógicos condicionais (veja 7.11.2 Operadores lógicos condicionais definidos pelo usuario). Exemplo No seguinte exemplo, observe que a expressão que utiliza && somente avalia o primeiro operando. // cs_operator_logical_and.cs using System; class Test { static bool fn1() { Console.WriteLine("fn1 called"); return false; } static bool fn2() { Console.WriteLine("fn2 called");
Visual C# Consolidado
254
return true; } public static void Main() { Console.WriteLine("regular AND:"); Console.WriteLine("result is {0}", fn1() & fn2()); Console.WriteLine("short-circuit AND:"); Console.WriteLine("result is {0}", fn1() && fn2()); } }
Resultado regular AND: fn1 called fn2 called result is False short-circuit AND: fn1 called result is False
Visual C# Consolidado
255
DIRECTIVES PREPROCESSOR C# Esta seção discute diretivas pré-processamento é a linguagem C#: #IF # Else #elif #endif Definir # #undef #warning #Error # Line #Region #endregion # pragma Aviso # pragma Soma de verificação # pragma Enquanto o compilador não não têm um preprocessor separado, as diretivas descritas nesta seção são processadas como se não havia um; essas diretivas são usadas para ajudar na compilação condicional. Ao contrário das diretivas C e C++, você não pode usar essas diretivas para criar macros. Uma diretiva de pré-processamento deve ser a única instrução em uma linha.
#If (referência C#) Permite que #if você iniciar uma diretiva condicional, teste um símbolo ou símbolos para ver se eles avaliada como true. Se eles fazer Avaliar a true, o compilador avaliará todo o código entre e #if a diretiva mais próximo #endif. Por exemplo, #define DEBUG // ... #if DEBUG Console.WriteLine("Debug version"); #endif Você pode usar os operadores == (igualdade), = (inequality), && (e). e || (ou) para avaliar vários símbolos Você também pode agrupar símbolos e operadores com parênteses. Comentários #if e #undef diretivas, permite que você incluir ou excluir código com base na condição de um ou mais símbolos., #endif juntamente com, Definir # o # Else, #elif Isso pode ser útil durante a compilação código para uma compilação de depuração ou quando compilar para uma configuração específica. Um começando diretiva condicional com uma #if diretiva explicitamente deve ser terminado com uma #endif diretiva. Permite que #define você defina um símbolo, que, usando o símbolo como a expressão transmitida para a #if diretiva, a expressão será avaliada para true. Você também pode definir um símbolo com a / Define opção de compilador. Você pode undefine um símbolo com #undef.
Visual C# Consolidado
256
Um símbolo que você define com /define ou com #define não entrará em conflito com uma variável com o mesmo nome. Isto é, um nome de variável não deve ser passado para uma Diretiva de pré-processamento e um símbolo só pode ser avaliado por uma diretiva de préprocessamento. O escopo de um símbolo criado com #define é o arquivo no qual ele foi definido. Exemplo // preprocessor_if.cs #define DEBUG #define VC_V7 using System; public class MyClass { static void Main() { #if (DEBUG && !VC_V7) Console.WriteLine("DEBUG is defined"); #elif (!DEBUG && VC_V7) Console.WriteLine("VC_V7 is defined"); #elif (DEBUG && VC_V7) Console.WriteLine("DEBUG and VC_V7 are defined"); #else Console.WriteLine("DEBUG and VC_V7 are not defined"); #endif } } Saída DEBUG and VC_V7 are defined
#Else Pessoa (referência C#) Permite que #else você crie uma diretiva condicional composta, para que, se nenhuma das expressões nas diretivas Anterior #IF ou (opcional) #elif para true, o compilador será avaliarão todo código entre #else e os subseqüentes #endif. Comentários Deve #endif ser a próxima diretiva pré-processamento após #else. Veja #IF um Exemplo de como usar #else.
#elif (referência C#) Permite que #elif você crie uma diretiva condicional composta. Será a #elif expressão ser avaliada se nem o precedente #IF nem todas as expressões anterior, opcional, #elif diretiva avaliada como true. Se uma #elif expressão avaliada como true, o compilador avaliará todo o código entre e #elif a próxima diretiva condicional. Por exemplo: #define VC7 //... #if debug Console.Writeline("Debug build"); #elif VC7 Console.Writeline("Visual Studio 7"); #endif Você pode usar os operadores == (igualdade), != (inequality), && (e). e || (ou), para avaliar vários símbolos Você também pode agrupar símbolos e operadores com parênteses. Comentários Equivale #elif a usar: #else #if Uso #elif é mais simples, porque cada #if requer pode ser usada sem um correspondente #endif. enquanto a #endif, um #elif Veja #IF um Exemplo de como usar #elif.
#endif (referência C#) Especifica #endif o término de uma diretiva condicional, que começou com a #IF diretiva. Por exemplo, #define DEBUG // ... #if DEBUG Console.WriteLine("Debug version"); #endif
Visual C# Consolidado
257
Comentários Uma diretiva condicional, começando com uma #if diretiva, explicitamente deve ser terminada com uma #endif diretiva. Veja #If (referência C#) um Exemplo de como usar #endif.
# Definir (referência C#) Permite que #define você defina um símbolo, para que, usando o símbolo como a expressão transmitida para a #IF diretiva, a expressão será avaliada para true. Por exemplo: #define DEBUG Comentários Símbolos podem ser usados para especificar condições para a compilação. Você pode testar para o símbolo com um #IF ou #elif. Você também pode usar o conditional atributo para executar compilação condicional. Você pode definir um símbolo, mas você pode atribuir um valor para um símbolo. A #define diretiva deve aparecer no arquivo antes de usar as instruções que são também não diretivas. Você também pode definir um símbolo com a / Define opção de compilador. Você pode undefine um símbolo com #undef. Um símbolo que você define com /define ou com #define não entrará em conflito com uma variável com o mesmo nome. Isto é, um nome de variável não deve ser passado para uma Diretiva de pré-processamento e um símbolo só pode ser avaliado por uma diretiva de préprocessamento. O escopo de um símbolo criado com #define é o arquivo no qual ele foi definido. Veja #IF um Exemplo de como usar #define.
#undef (referência C#) Permite que #undef você undefine um símbolo, que, usando o símbolo como a expressão em uma #IF diretiva, a expressão será avaliada para false. Um símbolo pode ser definido tanto com a Definir # diretiva ou a / Define opção de compilador. A #undef diretiva deve aparecer no arquivo antes de usar todas as instruções que são também não diretivas. Exemplo // preprocessor_undef.cs // compile with: /d:DEBUG #undef DEBUG using System; class MyClass { static void Main() { #if DEBUG Console.WriteLine("DEBUG is defined"); #else Console.WriteLine("DEBUG is not defined"); #endif } } Saída DEBUG is not defined
#warning (referência C#) Permite que #warning você gere um aviso um nível partir de um local específico em seu código. Por exemplo: #warning Deprecated code in this method. Comentários Um uso comum de #warning é em uma diretiva condicional. Também é possível para gerar um erro definido pelo usuário com #Error (referência C#).
Visual C# Consolidado
258
Exemplo // preprocessor_warning.cs // CS1030 expected #define DEBUG class MainClass { static void Main() { #if DEBUG #warning DEBUG is defined #endif } }
#Error (referência C#) Permite que #error você gerar um erro partir de um local específico em seu código. Por exemplo: #error Deprecated code in this method. Comentários Um uso comum de #error é em uma diretiva condicional. Também é possível para gerar um aviso definida pelo usuário com #warning (referência C#). Exemplo // preprocessor_error.cs // CS1029 expected #define DEBUG class MainClass { static void Main() { #if DEBUG #error DEBUG is defined #endif } }
# Line (referência C#) Permite que #line você modificar o compilador o número de linha e (opcionalmente) a saída nome de arquivo de erros e avisos. Este Exemplo mostra como para relatar dois avisos associados a números de linha. A #line 200 diretiva força o número de linha a ser 200 (embora o padrão seja #7). A outra linha (#9) segue a seqüência normal como um resultado da diretiva padrão #line. class MainClass { static void Main() { #line 200 int i; // CS0168 on line 200 #line default char c; // CS0168 on line 9 } } Comentários A #line diretiva pode ser usada em uma etapa no processo de criação automatizado e intermediários. Por exemplo, se linhas foram removidas do arquivo de código de fonte original, mas você queria o compilador para gerar saída com base em numeração no arquivo, a linha original ainda poderá remover linhas e depois simular a numeração original com #line Linha. A #line hidden diretiva oculta as linhas sucessivas do depurador, de modo que quando o desenvolvedor percorre o código, todas as linhas entre próxima #line diretiva (supondo que ele esteja não outra #line hidden Diretiva) e #line hidden o ser steppeds sobre será. Esta opção também pode ser usada para permitir ASP.NET para diferenciar entre código definido pelo usuário e máquina gerado. Embora ASP.NET seja o consumidor primário a esse recurso, é provável que mais origem geradores tornará usar dele. Uma #line hidden diretiva não afeta nomes ou números de linha no relatório de erros. Isto é, se um erro é encontrado em um bloco oculto, o compilador reportará o nome e linha número o erro de arquivo. A #line filename diretiva especifica o nome de arquivo você deseja que apareça na saída do compilador. Por padrão, o nome do arquivo de código de origem real é usado. O nome de arquivo deve ser entre aspas duplas () ". " Um arquivo código fonte pode ter qualquer número de #line diretivas. Exemplo 1
Visual C# Consolidado
259
O Exemplo a seguir mostra como o depurador ignora as linhas ocultas no código. Quando você executar o exemplo, ela exibirá três linhas de texto. No entanto, quando você define um ponto de interrupção, como mostrado no exemplo, e visitas F10 para passar pelo código, você notará que o depurador ignora a linha oculta. Observe também que mesmo que você defina um ponto de interrupção na linha oculta, o depurador irá ignorá-la ainda. // preprocessor_linehidden.cs using System; class MainClass { static void Main() { Console.WriteLine("Normal line #1."); // Set break point here. #line hidden Console.WriteLine("Hidden line."); #line default Console.WriteLine("Normal line #2."); } }
#Region (referência C#) Permite que #region você especifique um bloco de código que você pode expandir ou recolher quando usar o Estrutura de tópicos recurso do Editor de Código Visual Studio. Por exemplo: #region MyClass definition public class MyClass { static void Main() { } } #endregion Comentários Um #region bloco deve ser terminado com uma #endregion diretiva. Um #region bloco não pode se sobrepor a um #IF bloco. No entanto, um #region bloco pode ser aninhado em um #if bloco, e um #if bloco pode ser aninhado em um #region bloco.
#endregion (referência C#) Marca #endregion o final de um #Region bloco. Por exemplo: #region MyClass definition class MyClass { static void Main() { } } #endregion
# pragma (referência C#) é #pragma usado para fornecer as instruções especiais para a compilação do arquivo em que ele aparece do compilador #pragma pragma-name pragma-arguments Parâmetros pragma-name O nome de um pragma reconhecido. pragma-arguments Argumentos específicos Pragma-.
Aviso # pragma (referência C#) Pode #pragma warning ser usado para ativar ou desativar determinados avisos. #pragma warning disable warning-list #pragma warning restore warning-list Parâmetros warning-list
Visual C# Consolidado
260
Uma lista de números de aviso separted vírgulas. Digite os números sozinho, sem o prefixo " CS ". Quando nenhum número aviso são especificados, disable Desativa todos os avisos e restore permite que todos os avisos. Exemplo // pragma_warning.cs using System; #pragma warning disable 414, 3021 [CLSCompliant(false)] public class C { int i = 1; static void Main() { } } #pragma warning restore 3021 [CLSCompliant(false)] // CS3021 public class D { int i = 1; public static void F() { } }
Soma de verificação # pragma (referência C#) Pode ser usado para gerar somas de verificação para arquivos de origem para ajudar com depuração ASP.NET Páginas. #pragma checksum "filename" "{guid}" "checksum bytes" Parâmetros "filename" O nome do arquivo que requer o monitoramento de alterações ou atualizações. "{guid}" O Global Unique Identifier (GUID) para o arquivo. "checksum_bytes" A seqüência de dígitos hexadecimais representando os bytes da soma de verificação. Deve ser um número par de dígitos hexadecimais. Um número de dígitos resulta em um aviso em tempo de compilação, e a diretiva ímpar então será ignorado. Comentários O depurador Visual Studio usa uma soma de verificação para garantir que ele sempre encontrar a origem direita. O compilador calcula a soma de verificação para um arquivo de origem, e então emite a saída para arquivo de banco de dados (pdb) de programa. O depurador usa o PDB para comparar contra a soma de verificação que ele calcula para o arquivo de origem. Esta solução não funciona para ASP.NET projetos, pois a soma de comprovação calculada é para o arquivo de origem gerado, em vez do arquivo.aspx. Para resolver esse problema, #pragma checksum Fornece suporte checksum para ASP.NET Páginas. Quando você cria um ASP.NET projeto no Visual C#, o arquivo de origem gerado contém uma soma de verificação para o arquivo.aspx, do qual a fonte é gerada. O compilador grava essas informações para o arquivo PDB. Se o compilador encontrar nenhuma #pragma checksum Diretiva no arquivo, ele calcula a soma de verificação e grava o valor para o arquivo PDB. Exemplo class TestClass { static int Main() { #pragma checksum "file.cs" "{3673e4ca-6098-4ec1-890f8fceb2a794a2}" "{012345678AB}" // New checksum } }
Visual C# Consolidado
261
OPÇÕES DO COMPILADOR C# O compilador produz arquivos executável (.exe), bibliotecas de vínculo dinâmico (.dll), ou módulos de código (.netmodule). Cada opção de compilador está disponível de duas formas: -option e /option. A documentação só mostra o /option formulário.
Criando de linha de comando Você pode chamar o compilador C# simplesmente digitando o nome do seu arquivo executável (csc.exe) na linha de comando. Se você usar o prompt de comando Studio visual (disponível como um atalho no menu Iniciar no Visual Studio Tools), todas as variáveis de ambiente necessárias serão definidas para você. Caso contrário, você talvez precise ajustar o caminho para poder chamar csc.exe para ser chamado de qualquer subpasta em seu computador. Se você não usar o prompt de comando Studio visual, é necessário para executar vsvars32.bat para definir as variáveis de ambiente apropriada para oferecer suporte compilações linha de comando. Para obter mais informações sobre vsvars32.bat, consulte Como construir a partir da linha de comando:. Se você estiver trabalhando em um computador que só tem o SDK do .NET Framework, você pode usar o compilador C# na linha de comando se você usar que está disponível na Microsoft .NET Framework SDK opção de menu. o SDK Command Prompt, Para criar a partir do ambiente de desenvolvimento, consulte Preparar e gerenciando Builds. The csc.exe executable is usually located in the Microsoft.NET\Framework\ folder under the system directory. O local pode variar dependendo a configuração exata em qualquer computador individual. Várias versões deste executável será estar presentes na máquina se mais de uma versão do .NET Framework é instalado na máquina. Para obter mais informações sobre essas instalações, consulte Instalando várias versões do .NET Framework. Este tópico aborda o seguinte: Regras de sintaxe de linha de comando Linhas de comando de exemplo Diferenças entre compilador C# e C++ Saída do compilador Regras de sintaxe de linha de comando O compilador C# usa as regras a seguir ao interpretar argumentos fornecidos na linha de comando sistema operacional: •
Argumentos são delimitados por espaço em branco, que é um espaço ou uma guia.
•
O caractere de interpolação (^) não é reconhecido como um caractere de escape ou delimitador. O caractere é tratado completamente pelo analisador de linha de comando com o sistema operacional antes está sendo transmitido para a matriz argv no programa.
•
Uma seqüência rodeada por aspas duplas (" seqüência ") é interpretada como um argumento único, independentemente de espaço em branco contida. Uma seqüência entre aspas pode ser incorporada em um argumento.
•
Precedido de aspas duplas por uma barra invertida (. \ " é interpretado como um caractere literal aspas duplas ("))
•
Backslashes são interpretados literalmente, a menos que esteja imediatamente antes de aspas duplas.
Visual C# Consolidado
262
•
Se um número par de barras invertidas for seguido de aspas duplas, uma barra invertida é colocada na matriz argv para cada par de barras invertidas, e as aspas duplas é interpretada como um delimitador de seqüência de caracteres.
•
Se um número ímpar de barras invertidas for seguido de aspas duplas, uma barra invertida é colocada na matriz argv para cada par de barras invertidas, e as aspas duplas é " escaped ", a barra invertida restante, causando de aspas duplas (") para ser colocado em argv literal. Linhas de comando de exemplo Compila File.cs produzir File.exe:
•
csc File.cs Compila File.cs produzir File.dll:
•
csc /target:library File.cs Compila File.cs e cria My.exe:
•
csc /out:My.exe File.cs •
Compila todos os arquivos na pasta atual, com otimizações C# no e define o símbolo Debug. A saída é FILE2.exe: csc /define:DEBUG /optimize /out:File2.exe *.cs
•
Compila todos os arquivos na pasta atual produzir uma versão de depuração do FILE2.DLL C#. Nenhum logotipo e sem avisos são exibidos: csc /target:library /out:File2.dll /warn:0 /nologo /debug *.cs Compila todos os arquivos na pasta atual para Something.xyz (uma DLL) C#:
•
csc /target:library /out:Something.xyz *.cs Diferenças entre compilador C# e C++ Saída do compilador Não há nenhum arquivo de objeto (.obj), criados como resultado de chamar o compilador C#; arquivos de saída são criados diretamente. Como um consequence a isso, o compilador C# não precisa um vinculador.
Como construir a partir da linha de comando: O arquivo vsvars32.bat define as variáveis de ambiente apropriados para ativar builds.For linha de comando mais informações sobre vsvars32.bat, consulte o seguinte artigo Base de Conhecimento: Vcvars32.bat Generates fora da mensagem de ambiente Q248802:
•
Se a versão atual do Visual Studio estiver instalada em um computador que também possui uma versão anterior do Visual Studio, você não deve executar vsvars32.bat ou vcvars32.bat de versões diferentes na mesma janela de comando. Para executar VSVARS32.BAT 1.
No prompt de comando, mude para a subpasta Common7\Tools da instalação.
2.
Executar VSVARS32.bat digitando VSVARS32.
Cuidado VSVARS32.bat pode variar de máquina para máquina. Não substituir um arquivo VSVARS32.bat ausente ou danificado com um VSVARS32.bat do outro computador. Execute novamente a instalação para substituir o arquivo ausente.
Visual C# Consolidado
263
IMPLANTAÇÃO DE APLICATIVOS C# Após a conclusão criar seu aplicativo C#, a próxima etapa é para distribuí-lo. C# é uma linguagem .NET; portanto, distribuir qualquer executáveis C# para outras máquinas requer o .NET Framework para ser instalado em cada máquina de execução (e possivelmente outras dependências específicas para seu aplicativo). Você tem uma variedade de opções disponíveis para distribuir o .NET Framework. Para obter uma visão geral, consulte Redistribuindo o .NET Framework. Mover concluídos aplicativos para outros computadores é chamado geralmente de implantação. Ambiente de desenvolvimento da Microsoft fornece mecanismos para implantação; para obter mais informações, consulte Implantando aplicativos e componentes. Se você criar e distribuir principalmente na linha de comando, você talvez precise considerar outros métodos de implantação e redistribuindo dependências.
Opções do compilador C# listadas por categoria As seguintes opções do compilador são classificadas por categoria. Para obter uma lista alfabética, consulte Opções do compilador C# listadas Alphabetically.
Otimização Opção
Propósito
/filealign
Especifica o tamanho das seções no arquivo de saída.
/ Otimizar
Ativa / desativa otimizações.
Arquivos de saída Opção
Propósito
/Doc
Especifica um arquivo XML onde os comentários documentação processados são a serem gravados.
/ Fora
Especifica o arquivo de saída.
/PDB
Especifica o nome de arquivo e local do arquivo.pdb.
/platform Especificar a plataforma de saída. /target
Especifica o formato do arquivo de saída usando uma das quatro opções: /Target:exe/Target:Library/Target:Module/Target:winexe
Conjuntos .NET Framework Opção
Propósito
/addmodule
Especifica um ou mais módulos que faça parte deste conjunto de módulos (assembly).
/delaysign
Instrui o compilador para adicionar a chave pública mas para deixar o conjunto não assinado.
/keycontainer Especifica o nome do recipiente de chave de criptografia. /KeyFile
Especifica o nome do arquivo que contém a chave criptográfica.
/lib
Especifica o local de conjuntos referenciado por meio de /Reference.
Visual C# Consolidado
264
/nostdlib
Instrui o compilador Não para importar a biblioteca padrão (mscorlib.dll).
/Reference
Importa metadados de um arquivo que contém um conjunto.
Erros Debugging / verificação Opção
Propósito
/bugreport
Cria um arquivo que contém informações que torna fácil a relatar um erro.
/ selecionada
Especifica se fará com que uma exceção em tempo de execução inteiro aritmético que estoura os limites do tipo de dados.
/Debug
Instrua o compilador para emitir informações de depuração.
/errorreport
Define relatório comportamento erros.
/fullpaths
Especifica o caminho absoluto para o arquivo na saída do compilador.
/nowarn
Suprime o compilador na geração de avisos especificados.
/ Avisar
Define o nível de aviso.
/warnaserror Promove avisos a erros.
Preprocessor Opção
Propósito
/ Define
Define símbolos de pré-processamento.
Recursos Opção
Propósito
/linkresource
Cria um vínculo a um recurso gerenciado.
/Resource
Incorpora um recurso do .NET Framework no arquivo de saída.
/win32icon
Especifica um arquivo.ico para inserir no arquivo de saída.
/win32res
Especifica um recurso do Win32 para inserir no arquivo de saída.
Diversos Opção
Propósito
@
Especifica um arquivo de resposta.
/?
Lista opções do compilador para STDOUT.
/BaseAddress Especifica o endereço base preferido no qual se carregar um DLL. /Codepage
Especifica a página de códigos a ser usado para todos os arquivos de código de fonte a compilação.
/help
Lista opções do compilador para STDOUT.
/langversion
Especifica qual versão do idioma a ser usado.
/ Principal
Especifica o local do método Main.
/noconfig
Instrui o compilador não para compilar com CSC.RSP.
/nologo Evita
Suprime as informações de faixa do compilador.
/recurse
Procura subdiretórios para arquivos de origem para compilar.
Visual C# Consolidado
265
/ unsafe
Permite compilação do código que usa a Não seguro palavra-chave.
/utf8output
Exibe compilador saída usando a codificação UTF-8.
Obsoleto opções Permite compilação incremental.
/incremental
Opções do compilador C# listadas Alfabeticamente As seguintes opções do compilador são classificadas em ordem alfabética. Para obter uma lista categorical, consulte Opções do compilador C# listadas por categoria. Opção
Propósito
@
Lê um arquivo de resposta para obter mais opções.
/?
Exibe uma mensagem de uso para STDOUT.
/addmodule
Vincula os módulos especificados para este conjunto de módulos (assembly)
/BaseAddress Especifica o endereço base para a biblioteca a ser criado. /bugreport
Cria um arquivo ' Relatório de erros '. Este arquivo será enviado junto com qualquer informação de falha se usado com /errorreport:prompt ou /errorreport:Send.
/ selecionada Faz o compilador para gerar verificações de estouro. /Codepage
Especifica a página de código a ser utilizado quando abrir arquivos de origem.
/Debug
Emite as informações de depuração.
/ Define
Define símbolos de compilação condicional.
/delaysign
Signs atraso-o conjunto usando somente a parte pública da chave do nome de alta segurança.
/Doc
Especifica um arquivo de documentação XML para gerar.
/errorreport
Especifica como lidar com erros de compilador interno: prompt, envio, ou nenhum. O padrão é Nenhum.
/filealign
Especifica o alinhamento usado para seções de arquivo de saída.
/fullpaths
Faz o compilador para gerar caminhos totalmente qualificados.
/help
Exibe uma mensagem de uso para STDOUT.
/incremental Permite compilação incremental [obsoleta]. /keycontainer Especifica um recipiente de chave de nome de alta segurança. /KeyFile
Especifica um arquivo de chave de nome de alta segurança.
/langversion
Especifica modos de versão de idioma: ISO-1 ou padrão.
/lib
Especificar diretórios adicionais para procurar por referências em.
/linkresource
Vincula o recurso especificado a este conjunto.
/ Principal
Especifica o tipo que contém o ponto de entrada (Ignorar todos os outros pontos de entrada possíveis).
/noconfig
Instrui o compilador não para automaticamente incluir arquivo CSC.RSP.
/nologo Evita
Suprime mensagem de direitos autorais do compilador.
Visual C# Consolidado
266
/nostdlib
Instrui o compilador não à referência biblioteca padrão (mscorlib.dll).
/nowarn
Desativa específico mensagens de aviso
/ Otimizar
Ativa / desativa otimizações.
/ Fora
Especifica o nome do arquivo de saída (padrão:). base Nome do arquivo com classe principal ou primeiro arquivo
/PDB
Especifica o nome de arquivo e local do arquivo.pdb.
/platform
Limites que plataformas esse código pode executado em: x 86, Itanium, x 64, ou anycpu. O padrão é anycpu.
/recurse
Inclui todos os arquivos no diretório atual e subdiretórios de acordo com as especificações curinga.
/Reference
Metadados referências a partir dos arquivos conjunto especificado.
/Resource
Incorpora o recurso especificado.
/target
Especifica o formato do arquivo de saída usando uma das quatro opções: /Target:exe/Target:Library/Target:Module/Target:winexe
/ unsafe
Permite que Não seguro o código.
/utf8output
Saídas Mensagens do compilador em codificação UTF-8.
/ Avisar
Define o nível de aviso (0-4).
/warnaserror
Relatórios específicos avisos como erros.
/win32icon
Usa este ícone para a saída.
/win32res
Especifica o arquivo de recurso do Win32 (. res).
Como localizar ajuda para erros do compilador: Observação As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings (Importar e Exportar Configurações) no menu Tools (Ferramentas). Para obter mais informações, consulte Configurações do Visual Studio. Todos os Erros de compilador C# ter correspondentes tópicos que explique por que um erro é gerado, e em alguns casos, como corrigir o erro. Para obter ajuda sobre uma mensagem de erro específica, tente um destes procedimentos: Procedimento
Para encontrar Ajuda para um erro Clique no número de erro no e pressione F1. o Janela Output,
•
OuDigite o número do erro na caixa Look for no índice. OuDigite o número de erro na página Search.
Visual C# Consolidado
267
EXEMPLOS DO VISUAL C# Você pode acessar código de exemplo, procurando resumos de Exemplo nesta seção. Cada abstrato contém um link para abrir ou copiar o Exemplo na arquivos. Além disso, o SDK do .NET Framework inclui tecnologia e aplicativo Exemplos e tutoriais QuickStart que demonstram recursos .NET Framework e código Visual C#. Os tutoriais QuickStart são a maneira mais rápida para entender o que a tecnologia .NET Framework oferece desenvolvedores líder-borda. Os QuickStarts são uma série de exemplos e suporte documentação projetadas para rapidamente acquaint você com a sintaxe, arquitetura, e poder do Visual Studio e o .NET Framework. Do ASP.NET Os tutoriais QuickStart inclui exemplos na e aplicativos Windows Forms, além de muitos aplicativos instrução que abrangem os recursos da tecnologia .NET Framework mais atraentes. Para acessar o QuickStarts, clique em Start, aponte para Programs, aponte para Microsoft .NET Framework SDK v2.0, e clique em QuickStart Tutorials. Uma página da Web do aplicativo " tutoriais QuickStart SDK Microsoft .NET Framework " é exibida. Para executar o QuickStarts, siga as instruções na página, que configura o banco de dados amostras e conclui a instalação. Para obter mais informações, consulte Amostras e QuickStarts. Exemplos de introdução Anônimo Exemplo representantes
Demonstra o uso de representantes para reduzir a complexidade de aplicativos sem nome.
Exemplo matrizes
Mostra como usar matrizes.
Coleção Exemplo classes
Mostra como fazer classes coleção Generic não-que podem ser usados com a foreach instrução.
Exemplo generics (C#)
Mostra como fazer classes a coleção genérica que podem ser usados com a foreach instrução.
Exemplo de parâmetros Demonstra simples processamento de linha de comando e matriz da linha de comando indexação. Exemplo dos Métodos condicional
Demonstra condicionais métodos, que fornecem um poderoso mecanismo pelo qual chamadas para métodos podem ser incluídos ou omitido dependendo se um símbolo é definido.
Exemplo representantes Mostra como representantes são declaradas, mapeado, e combinados. Exemplo eventos
Mostra como usar eventos em C#.
Exemplo de implementação de interface explícita
Demonstra como explicitamente implementar membros de interface.
Exemplo World de saudação
Um aplicativo hello world.
Exemplo indexadores
Mostra como usar notação de matriz para acessar um objeto.
Indexado Exemplo propriedades
Mostra como a implementar uma classe que usa propriedades indexadas. Propriedades indexadas permitem que você para usar uma classe que representa uma coleção de vários tipos diferentes de itens semelhantes matriz-.
Exemplo propriedades
Mostra como propriedades são declaradas e usados; também demonstra propriedades abstratas.
Visual C# Consolidado
268
Exemplo Structs
Mostra como usar structs em C#.
Exemplo Overloading do operador
Mostra como definido pelo usuário classes poderá sobrecarregar operadores.
Exemplo Conversions definidas pelo usuário
Mostra como definir conversões de e para tipos definidos pelo usuário.
Exemplo de versão
Do override demonstra versão em C# através do uso de e new palavras-chave.
Produzir exemplo
Demonstra a palavra-chave rendimento para filtrar itens em uma coleção.
Exemplos intermediário e Avançado Exemplo atributos
Mostra como criar classes de atributo personalizado, usá-los em código, e consultá-los através de reflexão.
Exemplo parte 1 Interop COM
Mostra como usar C# para interoperar com objetos COM.
Exemplo parte 2 Interop COM
Mostra como um servidor use um C# com um cliente com C++.
Exemplo bibliotecas
Mostra como usar opções do compilador para criar uma DLL de vários arquivos de origem; além disso, como usar a biblioteca em outros programas.
Exemplo anulável
Demonstra tipos de valores que podem ser definidos como nulo.
Exemplo BD OLE
Demonstra como usar um banco de dados do Microsoft Access do C#. Ele mostra como você pode criar um DataSet e adicionar tabelas a ela a partir de um banco de dados.
Exemplo tipos parcial Demonstra como classes e estruturas podem ser definidas em vários arquivos código fonte-C#. Plataforma Invoke exemplo
Mostra como chamar exportadas funções DLL do C#.
Exemplo de segurança
Discute a segurança do .NET Framework e mostra duas maneiras de modificar as permissões de segurança em C#: Usando classes de permissão e atributos de permissão.
Segmentação de exemplo
Demonstra várias atividades do segmento, como criando e executando um segmento, sincronizando segmentos, interagir entre segmentos, e usando um pool de segmentos.
Exemplo de código não seguros
Mostra como usar ponteiros.
Exemplo de documentação XML
Mostra como a documentar código usando XML.
Exemplo World de saudação Download sample Este Exemplo mostra várias versões de um programa hello world em C#. Observação de segurança
Visual C# Consolidado
269
Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir os arquivos de Exemplo no Solution Explorer 1.
Clique em Download Sample. A caixa de mensagem Download de arquivo será exibida.
2.
Clique em Open e, na coluna esquerda da pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta os arquivos serão extraídos para, ou clique em Next novamente.
4.
Certifique-se de que a Show extracted files caixa de seleção esteja marcada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz a solução do projeto não é confiável. Clique OK para continuar. Para criar e executar os exemplos hello world no Visual Studio 1. 2.
Abra a solução (HelloWorld.sln). No Solution Explorer, clique com o projeto HelloWorld1, e clique em Set as StartUp Project.
3.
No menu Debug, clique em Start Without Debugging.
4.
Pressione qualquer tecla para fechar HelloWorld1.
5.
No Solution Explorer, clique com o projeto HelloWorld2, e clique em Set as StartUp Project.
6.
No menu Debug, clique em Start Without Debugging.
7.
Pressione qualquer tecla para fechar HelloWorld2.
8. 9.
No Solution Explorer, clique com o projeto HelloWorld3, e clique em Set as StartUp Project. No Solution Explorer, clique com o projeto HelloWorld3, e clique em Properties.
10. Abra a Configuration Properties pasta, e clique em Debug. 11. Na Command Line Arguments propriedade, tipo A B C D e clique em OK. 12. No menu Debug, clique em Start Without Debugging. 13. Pressione qualquer tecla para fechar HelloWorld3. 14. No Solution Explorer, clique com o projeto HelloWorld4, e clique em Set as StartUp Project. 15. No menu Debug, clique em Start Without Debugging. 16. Pressione qualquer tecla para fechar HelloWorld4. Para criar e executar os exemplos hello world a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório HelloWorld.
2.
Digite o seguinte:
Visual C# Consolidado
270
cd HelloWorld1 csc Hello1.cs Hello1 3.
Digite o seguinte: cd ..\HelloWorld2 csc Hello2.cs Hello2
4.
Digite o seguinte: cd ..\HelloWorld3 csc Hello3.cs Hello3 A B C D
5.
Digite o seguinte: cd ..\HelloWorld4 csc Hello4.cs Hello4
Consulte também
Exemplo de parâmetros da linha de comando Download sample Este Exemplo mostra como a linha de comando pode ser acessada e duas maneiras de acessar a matriz de parâmetros de linha de comando. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos parâmetros de linha de comando no Visual Studio 1.
No Solution Explorer, clique com o projeto CmdLine1, e clique em Set as StartUp Project.
2.
No Solution Explorer, clique com o projeto, e clique em Properties.
3.
Abra a Configuration Properties pasta, e clique em Debug.
4.
Na propriedade Command Line Arguments, digite os parâmetros da linha de comando, e clique em OK. (Consulte o tutorial para obter um exemplo.)
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para CmdLine2.
Para criar e executar os exemplos parâmetros de linha de comando a partir da linha de comando
Visual C# Consolidado
271
1.
Use o Change Directory comando para alterar para o diretório CmdLine1.
2.
Digite o seguinte: csc cmdline1.cs cmdline1 A B C
3.
Use o Change Directory comando para alterar para o diretório CmdLine2.
4.
Digite o seguinte: csc cmdline2.cs cmdline2 John Paul Mary
Exemplo matrizes Download sample Este Exemplo descreve e mostra como matrizes funcionam em C#. Para obter mais informações, consulte Matrizes (Guia de programação do C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo matrizes no Visual Studio •
No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo matrizes a partir da linha de comando •
Digite o seguinte no prompt de comando: csc arrays.cs arrays
Exemplo propriedades Download sample Este Exemplo mostra como propriedades são uma parte integral da C# linguagem de programação. Ele demonstra como propriedades são declaradas e usados. Consulte Propriedades Para obter mais informações. Observação de segurança
Visual C# Consolidado
272
Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos propriedades no Visual Studio 1.
No Solution Explorer, clique com o projeto pessoa e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para shapetest.
Para criar e executar os exemplos Propriedades a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório pessoa.
2.
Digite o seguinte: csc person.cs person
3.
Use o Change Directory comando para alterar para o diretório shapetest.
4.
Digite o seguinte: csc abstractshape.cs shapes.cs shapetest.cs shapetest
Exemplo bibliotecas Download sample Este Exemplo mostra como criar e usar uma DLL em C#. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
Visual C# Consolidado
273
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo bibliotecas no Visual Studio 1.
No Solution Explorer, clique com o projeto FunctionTest, e clique em Set as StartUp Project.
2.
No Solution Explorer, clique com o projeto FunctionTest, e clique em Properties.
3.
Abra a Configuration Properties pasta e clique em Debug.
4.
Na propriedade Command Line Arguments, insira 3 5 10.
5.
Clique em OK.
6.
No menu Debug, clique em Start Without Debugging. Isso automaticamente criar a biblioteca em funções e executar o programa.
Para criar e executar o Exemplo bibliotecas a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório funções.
2.
Digite o seguinte: csc /target:library /out:Functions.dll Factorial.cs DigitCounter.cs
3.
Use o Change Directory comando para alterar para o diretório FunctionTest.
Exemplo de versão Download sample Este Exemplo demonstra versão em C# através do uso de e new palavras-chave. o override Versão ajuda manter a compatibilidade entre classes base e derivados como eles evoluir. Para obter informações adicionais, consulte Versão com o substituição e palavras-chave new (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer
Visual C# Consolidado
274
1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo versão no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo versão a partir da linha de comando Digite o seguinte no prompt de comando:
•
csc versioning.cs versioning
Coleção Exemplo classes Download sample Este Exemplo mostra como a implementar uma classe coleção que pode ser usado com a foreach instrução. Para obter mais informações, consulte Classes coleção (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
Visual C# Consolidado
275
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos classes coleção no Visual Studio 1.
No Solution Explorer, clique com o projeto CollectionClasses1 e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para CollectionClasses2.
Para criar e executar os exemplos classes coleção a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório CollectionClasses1.
2.
Digite o seguinte: csc tokens.cs tokens
3.
Use o Change Directory comando para alterar para o diretório CollectionClasses2.
4.
Digite o seguinte: csc tokens2.cs tokens2
Exemplo Structs Download sample Este Exemplo apresenta a sintaxe e uso de estruturas. Ele também aborda as diferenças importantes entre classes e estruturas. Consulte Objetos, classes e Structs (guia de programação C#) Para obter mais informações. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Structs no Visual Studio
Visual C# Consolidado
276
1.
No Solution Explorer, clique com o projeto Struct1 e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para Struct2.
Para criar e executar os exemplos Structs a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório Struct1.
2.
Digite o seguinte: csc struct1.cs struct1
3.
Use o Change Directory comando para alterar para o diretório Struct2.
4.
Digite o seguinte: csc struct2.cs struct2
Exemplo indexadores Download sample Este Exemplo mostra como classes C# podem declarar indexadores para fornecer acesso semelhante matriz-às classes. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo Indexers no Visual Studio 1.
No Solution Explorer, clique com o projeto indexadores, e clique em Properties.
2.
Abra a Configuration Properties pasta, e clique em Debug.
3.
Na propriedade Command Line Arguments, insira ..\..\Test.txt.
4.
Clique em OK.
Visual C# Consolidado
277
5.
No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo Indexers a partir da linha de comando 1.
Para compilar o programa de exemplo, digite o seguinte no prompt de comando: csc indexer.cs
O programa de Exemplo inverte os bytes em um arquivo fornecido como um argumento da linha de comando. Por exemplo, para reverter os bytes em Test.txt e ver o resultado, emitir os seguintes comandos: indexers Test.txt type Test.txt 2.
Para alterar o arquivo revertido para Normal, execute o programa no mesmo arquivo novamente.
Indexado Exemplo propriedades Download sample Este Exemplo mostra como classes C# podem declarar indexadas propriedades para representa uma coleção de tipos diferentes de itens semelhantes matriz-. Para obter mais informações, consulte Propriedades (Guia de programação do C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo indexado propriedades no Visual Studio •
No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo indexado Propriedades a partir da linha de comando •
Digite o seguinte no prompt de comando: csc indexedproperty.cs indexedproperty
Visual C# Consolidado
278
Exemplo Conversions definidas pelo usuário Download sample Este Exemplo mostra como definir conversões de ou para classes ou estruturas, e como essas conversões são usados. Consulte Operadores de conversão (guia de programação C#) Para obter mais informações. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Conversions pelo usuário no Visual Studio 1.
No Solution Explorer, clique com o projeto Conversion1 e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para Conversion2.
Para criar e executar os exemplos Conversions pelo usuário a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório Conversion1.
2.
Digite o seguinte: csc conversion.cs conversion
3.
Use o Change Directory comando para alterar para o diretório Conversion2.
4.
Digite o seguinte: csc structconversion.cs structconversion
Exemplo generics (C#) Download sample Este Exemplo mostra como criar uma classe personalizada lista genérico com um parâmetro único tipo, e como implementá IEnumerable Para ativar foreach iteração através do conteúdo
Visual C# Consolidado
279
da lista. O Exemplo também mostra como código de cliente cria uma instância da classe, especificando um argumento Tipo, e como restrições sobre o parâmetro type ativar operações adicionais a serem executadas sobre os argumentos Tipo. Para obter um Exemplo de uma classe a coleção genérica que implementa um bloco do iterador, consulte COMO: Criar um bloco iterador para uma lista genérica (Guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo Generics no Visual Studio •
No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo Generics a partir da linha de comando •
Digite o seguinte no prompt de comando: csc generics.cs generics
Comentários Este Exemplo é fornecido para fins de demonstração e não se destina a ser usado sem modificações no código de produção. Para código de qualidade de produção, ele é recomendável que você usar as classes coleção no espaço para nome System.Collections.Generic sempre que possível.
Exemplo Overloading
do operador
Download sample Este Exemplo demonstra classes definidas pelo usuário como poderá sobrecarregar operadores. Consulte Operadores C# Para obter mais informações. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
Visual C# Consolidado
280
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Overloading operador no Visual Studio 1.
No Solution Explorer, clique com o projeto complexo e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para Dbbool.
Para criar e executar os exemplos operador Overloading a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório complexo.
2.
Digite o seguinte: csc complex.cs complex
3.
Use o Change Directory comando para alterar para o diretório Dbbool.
4.
Digite o seguinte: csc dbbool.cs dbbool
Exemplo representantes Download sample Este Exemplo demonstra os tipos de representante. Ele mostra como para mapear delegados para estáticos e métodos da instância, e como combiná-las para criar representantes de difusão seletiva. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer
Visual C# Consolidado
281
1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos representantes no Visual Studio 1.
No Solution Explorer, clique com o projeto Delegates1, e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para Delegates2.
Para criar e executar os exemplos representantes a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório Delegates1.
2.
Digite o seguinte: csc bookstore.cs bookstore
3.
Use o Change Directory comando para alterar para o diretório Delegates2.
4.
Digite o seguinte: csc compose.cs compose
Exemplo eventos Download sample Este Exemplo mostra como a declarar, chamar, e configurar eventos em C#. Para obter mais informações, consulte Eventos (Guia de programação do C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files.
Visual C# Consolidado
282
O Extraction Wizard abre. 3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos eventos no Visual Studio 1.
No Solution Explorer, clique com o projeto Events1, e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para Events2.
Para criar e executar os exemplos eventos a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório Events1.
2.
Digite o seguinte: csc events1.cs events1
3.
Use o Change Directory comando para alterar para o diretório Events2.
4.
Digite o seguinte: csc events2.cs events2
Exemplo de implementação de interface explícita Download sample Este Exemplo demonstra como explicitamente implementar membros de interface e como acessar esses participantes a partir de ocorrências interface. Para informações de plano de fundo, consulte Interfaces (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente.
Visual C# Consolidado
283
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish. Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Explicit implementação interface no Visual Studio 1.
No Solution Explorer, clique com o projeto ExplicitInterface1 e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para ExplicitInterface2.
Para criar e executar os exemplos Explicit implementação interface a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório ExplicitInterface1.
2.
Digite o seguinte: csc explicit1.cs explicit1
3.
Use o Change Directory comando para alterar para o diretório ExplicitInterface2.
4.
Digite o seguinte: csc explicit2.cs explicit2
Exemplo dos Métodos condicional Download sample Este Exemplo demonstra condicionais métodos, que fornecem um poderoso mecanismo pelo qual chamadas para métodos podem ser incluídos ou omitido dependendo se um símbolo é definido. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar.
Visual C# Consolidado
284
Para criar e executar o Exemplo métodos condicional no Visual Studio 1.
No Solution Explorer, clique com o projeto e clique em Properties.
2.
Abra a pasta Propriedades de configuração, e clique em Debug.
3.
Defina a Command Line Arguments propriedade para A B C.
4.
Na pasta Propriedades de configuração, clique em Build.
5. 6.
Modificar a Conditional Compilation Constants propriedade. Por exemplo, adicionar ou excluir Debug. Clique em OK. No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo métodos condicional a partir da linha de comando •
Para incluir o método condicional, compilar e execute o programa de exemplo, digitando o seguinte no prompt de comando: csc CondMethod.cs tracetest.cs /d:DEBUG tracetest A B C
Exemplo de documentação XML Download sample Este Exemplo mostra como usar XML ao documento código. Consulte Comentários de documentação XML (Guia de programação C#) Para obter informações adicionais. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar o Exemplo documentação XML no Visual Studio 1.
No Solution Explorer, clique com o projeto e clique em Properties.
2.
Abra a pasta Propriedades de configuração e clique em Build.
3.
Defina a propriedade arquivo documentação XML como XMLsample.xml.
Visual C# Consolidado
285
4.
No menu Build, clique em Build. O arquivo de saída XML poderá ser no diretório de depuração.
Para criar o Exemplo documentação XML a partir da linha de comando 1.
Para gerar a documentação XML de exemplo, digite o seguinte no prompt de comando: csc XMLsample.cs /doc:XMLsample.xml
2.
Para ver o XML gerado, emita o seguinte comando: type XMLsample.xml
Plataforma Invoke Exemplo Download sample Este Exemplo demonstra como chamar plataforma chama (funções exportadas DLL) do C#. Consulte Interoperabilidade (guia de programação C#) Para obter mais informações. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Platform Invoke no Visual Studio 1.
No Solution Explorer, clique com o projeto PinvokeTest e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para Marshal e PInvoke.
Para criar e executar os exemplos Platform Invoke a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório PinvokeTest.
2.
Digite o seguinte: csc PinvokeTest.cs PinvokeTest
3.
Use o Change Directory comando para alterar para o diretório Marshal.
Visual C# Consolidado
286
4.
Digite o seguinte: csc Marshal.cs Marshal
5.
Use o Change Directory comando para alterar para o diretório PInvoke.
6.
Digite o seguinte: csc logfont.cs pinvoke.cs pinvoke
Exemplo parte 1 Interop COM Download sample Este Exemplo demonstra como um programa C# pode interoperar com um componente COM não gerenciado. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos com Interop parte 1 no Visual Studio 1.
No Solution Explorer, clique com o projeto Interop1, e clique em Set as StartUp Project.
2.
No Solution Explorer, clique com o projeto Interop1, e clique em Properties.
3.
Abra a Configuration Properties pasta, e clique em Debug.
4.
Na propriedade argumentos de linha de comando, digite um arquivo AVI como c:\winnt\clock.avi.
5.
Clique em OK.
6.
No menu Debug, clique em Start Without Debugging.
7.
Repita as etapas anteriores para Interop2.
Se o QuartzTypeLib.dll incluído com Interop1 está desatualizado 1.
No Solution Explorer, abrir References para Interop1.
Visual C# Consolidado
287
2.
Clique com o botão direito do mouse QuartzTypeLib e, clique em Remove.
3.
Clique com o botão direito do mouse References e, clique em Add Reference.
4.
Na guia COM, selecione o componente denominado, " biblioteca Tipo de Controle ActiveMovie ".
5.
Clique em Select e, clique em OK.
6.
Recrie Interop1.
Observação Adicionando uma referência para o componente faz a mesma coisa que chamar TLBIMP na linha de comando para criar QuartzTypeLib.dll (como mostrado abaixo). Para criar e executar os exemplos com Interop Parte 1 a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório Interop1.
Use o Change Directory comando para alterar para o diretório Interop2.
4.
Digite o seguinte: csc interop2.cs interop2 %windir%\clock.avi
Exemplo parte 2 Interop COM Download sample Este Exemplo demonstra usando um servidor C# com um cliente com C++. Observação É preciso instalar para compilar Este Exemplo Visual C++. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente.
Visual C# Consolidado
288
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish. Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo 2 Part Interop COM no Visual Studio 1.
No Solution Explorer, clique com o projeto COMClient, e clique em Properties.
2.
Abra a Configuration Properties pasta, e clique em Debug.
3.
Na propriedade Command Line Arguments, digite um nome.
4.
Clique em OK.
5.
No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo 2 Part Interop COM a partir da linha de comando 1. 2.
Use o Change Directory comando para alterar para o diretório COMInteropPart2\COMClient. Copie o código do servidor C# para o diretório COMClient: copy ..\CSharpServer\CSharpServer.cs
3.
Compilar o servidor: csc /target:library CSharpServer.cs regasm CSharpServer.dll /tlb:CSharpServer.tlb
4.
Compilar o cliente (verifique se as variáveis Caminho e ambiente são definidas corretamente com vcvars32.bat):: cl COMClient.cpp
5.
Execute o cliente: COMClient friend
Exemplo atributos Download sample Este Exemplo demonstra como criar classes de atributo personalizado, usá-los em código, e consultá-los através de reflexão. Para obter mais informações sobre atributos, consulte Atributos (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
Visual C# Consolidado
289
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo atributos no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo atributos a partir da linha de comando Digite o seguinte no prompt de comando:
•
csc AttributesTutorial.cs AttributesTutorial
Exemplo de segurança Download sample Este Exemplo demonstra como modificar as permissões de segurança através de classes de permissão e atributos de permissão. Para obter informações adicionais, consulte Segurança (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos de segurança no Visual Studio 1. 2.
No Solution Explorer, clique com o projeto Security1 e clique em Set as StartUp Project. No menu Debug, clique em Start Without Debugging.
Visual C# Consolidado
290
3.
Repita as etapas anteriores para Security2 e Security3.
Para criar e executar os exemplos de segurança a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório Security1.
2.
Digite o seguinte: csc ImperativeSecurity.cs ImperativeSecurity
3.
Use o Change Directory comando para alterar para o diretório Security2.
4.
Digite o seguinte: csc DeclarativeSecurity.cs DeclarativeSecurity
5.
Use o Change Directory comando para alterar para o diretório Security3.
6.
Digite o seguinte: csc SuppressSecurity.cs SuppressSecurity
Segmentação de Exemplo Download sample Este Exemplo demonstra as seguintes técnicas segmentação. Consulte Segmentação (guia de programação C#) Para obter mais informações. •
Criar, iniciar, e Finalizando um segmento
•
Usando um pool de segmentos
•
Segmento Sincronização e interação Observação de segurança
Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Threading no Visual Studio
Visual C# Consolidado
291
1.
No Solution Explorer, clique com o projeto ThreadStartStop e clique em Set as StartUp Project.
2.
No menu Debug, clique em Start Without Debugging.
3.
Repita as etapas anteriores para ThreadPool, e ThreadSync.
Para criar e executar os exemplos Threading a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório segmentos.
2.
Digite o seguinte: cd ThreadStartStop csc ThreadStartStop.cs ThreadStartStop
3.
Digite o seguinte: cd ..\ThreadPool csc ThreadPool.cs ThreadPool
4.
Digite o seguinte: cd ..\ThreadSync csc ThreadSync.cs ThreadSync
Exemplo de código não seguros Download sample Este Exemplo demonstra como usar código não gerenciado (código usando ponteiros) no C#. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos UNSAFE código no Visual Studio 1. 2.
No Solution Explorer, clique com o projeto FastCopy, e clique em Set as StartUp Project. No menu Debug, clique em Start Without Debugging.
Visual C# Consolidado
292
3.
No Solution Explorer, clique com o projeto ReadFile, e clique em Set as StartUp Project.
4.
No Solution Explorer, clique com o projeto ReadFile, e clique em Properties.
5.
Abra a pasta Propriedades de configuração, e clique em Debug.
6.
Na propriedade argumentos da linha de comando, insira ..\..\ReadFile.cs.
7.
Clique em OK.
8.
No menu Debug, clique em Start Without Debugging.
9.
No Solution Explorer, clique com o projeto PrintVersion, e clique em Set as StartUp Project.
10. No menu Debug, clique em Start Without Debugging. Para criar e executar os exemplos de código UNSAFE a partir da linha de comando 1.
Use o Change Directory comando para alterar para o diretório UNSAFE.
2.
Digite o seguinte: cd FastCopy csc FastCopy.cs /unsafe FastCopy
3.
Digite o seguinte: cd ..\ReadFile csc ReadFile.cs /unsafe ReadFile ReadFile.cs
4.
Digite o seguinte: cd ..\PrintVersion csc PrintVersion.cs /unsafe PrintVersion
Exemplo BD OLE Download sample Este Exemplo demonstra como usar um banco de dados do Microsoft Access do C#. Ele mostra como você pode criar um DataSet e adicionar tabelas a ela a partir de um banco de dados. O banco de dados BugTypes.MDB usado no programa de Exemplo é um arquivo.mdb do Microsoft Access 2000. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Visual C# Consolidado
293
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo de banco de dados OLE no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Observação Se você estiver criando a solução no modo Release, copie BugTypes.mdb para a pasta \bin\release. Para criar e executar o Exemplo OLE DB a partir da linha de comando Digite o seguinte no prompt de comando:
•
csc oledbsample.cs oledbsample
Produzir Exemplo Download sample Este Exemplo mostra como criar uma classe lista que implementa IEnumerable e palavra-chave yield Para ativar foreach iteração através do conteúdo da lista. Duas propriedades são definidas, um retornar os números ímpares, o outro retornar os números pares. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo YIELD código no Visual Studio •
No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo YIELD código a partir da linha de comando
Visual C# Consolidado
294
1.
Use o Change Directory (cd) comando para alterar para o Yield Diretório.
2.
Digite o seguinte: csc Yield.cs Yield
Anônimo Exemplo representantes Download sample Este Exemplo demonstra usar um representante anônimo para calcular um bônus do salário de um funcionário. Usar um representante anônimo simplifica o programa porque não é necessário para definir um método separado. Os dados para cada funcionário são armazenados em um objeto que contém detalhes pessoais, bem como um representante que referencia o algoritmo necessário para calcular o bônus. Definindo o algoritmo por meio de um representante, o mesmo método pode ser usado para executar o cálculo do bônus, independentemente de como ele é realmente calculado. De anotação, uma variável local, multiplicador, também se torna uma variável externo capturado porque ele é mencionado em um cálculo delegado. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo de código AnonymousDelegates no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo de código AnonymousDelegates a partir da linha de comando 1. 2.
Use o Change Directory (cd) comando para alterar para o diretório AnonymousDelegates. Digite o seguinte: csc AnonymousDelegates.cs AnonymousDelegates
Visual C# Consolidado
295
Exemplo tipos parcial Download sample Este Exemplo demonstra o uso de tipos parciais que permitem class ou struct para ser definidos em dois ou mais arquivos C#. Isso permite que vários programadores para trabalhar em partes diferentes de uma classe em paralela, e para aspectos diferentes de uma classe complexo a serem mantidos em arquivos separados. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo de código PartialTypes no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo de código PartialTypes a partir da linha de comando 1.
Use o Change Directory (cd) comando para alterar para o PartialTypes Diretório.
2.
Digite o seguinte: csc PartialTypes.cs PartialTypes
Exemplo anulável Download sample Este Exemplo demonstra o uso de tipos anuláveis. Esse recurso permite que tipos de valores para que um estado não inicializada, ou vazio, semelhante a como tipos de referência podem ser definidos como null. Este Observação de segurança código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada
Visual C# Consolidado
296
Para abrir o arquivo de Exemplo no Solution Explorer 1.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
2.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
3.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo Nullable código no Visual Studio 1. 2.
Abra Nullable.sln, o arquivo de solução, o clicando duas vezes no arquivo no Windows Explorer, ou clicando Open no menu File. No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo de código Nullable a partir da linha de comando 1.
Use o Change Directory (cd) comando para alterar para o diretório Nullable.
2.
Digite o seguinte: csc Nullable.cs Nullable
Visual C# Consolidado
297
TERMINOLOGIA C# Modificador de acesso Uma palavra-chave, como Particular, Protegido ou Pública, que restringe o acesso a um tipo ou membro Tipo., interno Para obter mais informações, consulte Modificadores de acesso. Membro acessível Um membro que pode ser acessado por um tipo determinado. Um membro acessível para um tipo não está necessariamente acessível para um outro tipo. Para obter mais informações, consulte Modificadores de acesso e Conjuntos de amigo. Assessor Um método que Define ou recupera o valor de um valor que está associado a uma propriedade membro dados particulares. Propriedades de leitura-gravação e set ter get assessores. Propriedades que são somente leitura têm apenas um get acessador. Para obter mais informações, consulte Propriedades. Método anônimo Um método anônimo é um bloco de código que é passado como um parâmetro para um Delegar. Para obter mais informações, consulte Métodos anônimo. Classe base Uma Classe que é herdado por outra classe ' derivado '. Para obter mais informações, consulte Herança. Chamar pilha A série de método chama à esquerda do início do programa para a instrução atualmente sendo executado em tempo de execução. Classe Um tipo de dados que descreve um objeto. Classes conter dados, e os métodos para agir sobre os dados. Para obter mais informações, consulte Classes. Construtor Um método especial em class ou struct que inicializa os objetos do mesmo tipo. Para obter mais informações, consulte Construtores. Delegar Um representante é um tipo que referencia um método. Depois que um representante é atribuído um método, ele funciona exatamente como esse método. Para obter mais informações, consulte Representantes. Classe derivada Um Classe que usa herança para obter, aumentar, ou modificar o comportamento e dados de outra classe ' base '. Para obter mais informações, consulte Herança. destruidor Um método especial em ou struct que prepara a instância para Destruição pelo sistema. um Classe Para obter mais informações, consulte Destructors. Evento Um membro da OU struct que envia notificações de alteração. um Classe Para obter mais informações, consulte Eventos.
Visual C# Consolidado
298
Campo Um membro de dados ou struct que é acessado diretamente. um Classe generics Generics permitir que você a definir e ou método que são definidas com um parâmetro de tipo. um Classe Quando código cliente instancia o tipo, ele especifica um tipo específico como um argumento. Para obter mais informações, consulte Generics. IDE Ambiente de desenvolvimento integrado. O aplicativo que fornece a interface do usuário unificada para as ferramentas de desenvolvimento vários incluindo o compilador, depurador, editor de código, e designers. Tipo imutável Um tipo cujos dados de instância, campos e propriedades, não altera depois a instância for criada. A maioria dos tipos valor são imutáveis. Membro inacessível Um membro que não pode ser acessado por um tipo determinado. Um membro inacessível para um tipo é não necessariamente inacessível para outro tipo. Para obter mais informações, consulte Modificadores de acesso. Herança C# herança oferece suporte, para uma Classe que deriva de outra classe, conhecido como a classe base, herda os mesmos métodos e propriedades. Herança envolve classes base e classes derivadas. Para obter mais informações, consulte Herança. Interface Um tipo que contém somente as assinaturas de métodos públicos, eventos e representantes. Um objeto que herda a interface deve implementar todos os métodos e eventos definidos na interface. Classes ou estruturas podem herdar qualquer número de interfaces. Para obter mais informações, consulte Interfaces iterador Um iterador é um método que permite que os consumidores de uma Classe que contém uma coleção ou matriz para usar foreach, na referência (C#) para percorrer essa coleção ou matriz. Membro Um campo, propriedade, método, ou evento declarado no ou struct. um Classe Método Um bloco de códigos nomeado que fornece comportamento para ou struct. um Classe Tipo mutáveis Um tipo cujos dados de instância, campos e propriedades, podem ser alteradas após a ocorrência é criada. A maioria Tipos de referência está mutáveis. tipo aninhado Um tipo declarado na declaração de outro tipo. object Uma instância de um Classe. Um objeto existe na memória, e tem dados e métodos que atuam sobre os dados. Para obter mais informações, consulte Objetos, classes, e Structs. Propriedade
Visual C# Consolidado
299
Um membro de dados acessado por meio de um acessador. Para obter mais informações, consulte Propriedades. refatoração Reutilizando anteriormente digitado código. Visual Express Editor código C# inteligentemente pode reformatar código para, por exemplo, transformar um bloco de código de realce em um método. Para obter mais informações, consulte Refatoração. Tipo de referência Um tipo de dados. Uma variável declarada como um ponto Tipo de referência para um local em que os dados são armazenados. Para obter mais informações, consulte Tipos de referência. static Existe uma classe ou método declarado como estático sem primeiro sendo instanciado usando a palavra-chave new. é Main() um método estático. Para obter mais informações, consulte Classes estáticas e membros de classe estáticos. struct Um tipo composto dados que é normalmente usado para conter algumas variáveis que têm alguma relação lógica. Structs também podem conter métodos e eventos. Structs não oferecerem suporte herança mas eles fazer suporte interfaces. É uma estrutura a Tipo de valor,. enquanto é um Classe um Tipo de referência Para obter mais informações, consulte Structs. Tipo de valor Um tipo de valor é um tipo de dados que está alocado na pilha, em um tipo de referência que é alocado em pilha vez. Incluindo o Tipos internas, os tipos numéricos, bem como o tipo estrutura e o tipo anulável, são todos os tipos valor. O Classe tipo e Seqüência Tipo são Tipos de referência. Para obter mais informações, consulte Tipos valor (referência C#).
Visual C# Consolidado
300
EXEMPLOS DO VISUAL C# Você pode acessar código de exemplo, procurando resumos de Exemplo nesta seção. Cada abstrato contém um link para abrir ou copiar o Exemplo na arquivos. Além disso, o SDK do .NET Framework inclui tecnologia e aplicativo Exemplos e tutoriais QuickStart que demonstram recursos .NET Framework e código Visual C#. Os tutoriais QuickStart são a maneira mais rápida para entender o que a tecnologia .NET Framework oferece desenvolvedores líder-borda. Os QuickStarts são uma série de exemplos e suporte documentação projetadas para rapidamente acquaint você com a sintaxe, arquitetura, e poder do Visual Studio e o .NET Framework. Do ASP.NET Os tutoriais QuickStart inclui exemplos na e aplicativos Windows Forms, além de muitos aplicativos instrução que abrangem os recursos da tecnologia .NET Framework mais atraentes. Para acessar o QuickStarts, clique em Start, aponte para Programs, aponte para Microsoft .NET Framework SDK v2.0, e clique em QuickStart Tutorials. Uma página da Web do aplicativo " tutoriais QuickStart SDK Microsoft .NET Framework " é exibida. Para executar o QuickStarts, siga as instruções na página, que configura o banco de dados amostras e conclui a instalação. Para obter mais informações, consulte Amostras e QuickStarts. Nesta seção Exemplos de introdução Anônimo Exemplo representantes
Demonstra o uso de representantes para reduzir a complexidade de aplicativos sem nome.
Exemplo matrizes
Mostra como usar matrizes.
Coleção Exemplo classes
Mostra como fazer classes coleção Generic não-que podem ser usados com a foreach instrução.
Exemplo generics (C#)
Mostra como fazer classes a coleção genérica que podem ser usados com a foreach instrução.
Exemplo de parâmetros Demonstra simples processamento de linha de comando e matriz da linha de comando indexação. Exemplo dos Métodos condicional
Demonstra condicionais métodos, que fornecem um poderoso mecanismo pelo qual chamadas para métodos podem ser incluídos ou omitido dependendo se um símbolo é definido.
Exemplo representantes Mostra como representantes são declaradas, mapeado, e combinados. Exemplo eventos
Mostra como usar eventos em C#.
Exemplo de implementação de interface explícita
Demonstra como explicitamente implementar membros de interface.
Visual C# Consolidado
301
Exemplo World de saudação
Um aplicativo hello world.
Exemplo indexadores
Mostra como usar notação de matriz para acessar um objeto.
Indexado Exemplo propriedades
Mostra como a implementar uma classe que usa propriedades indexadas. Propriedades indexadas permitem que você para usar uma classe que representa uma coleção de vários tipos diferentes de itens semelhantes matriz-.
Exemplo propriedades
Mostra como propriedades são declaradas e usados; também demonstra propriedades abstratas.
Exemplo Structs
Mostra como usar structs em C#.
Exemplo Overloading do operador
Mostra como definido pelo usuário classes poderá sobrecarregar operadores.
Exemplo Conversions definidas pelo usuário
Mostra como definir conversões de e para tipos definidos pelo usuário.
Exemplo de versão
Do override demonstra versão em C# através do uso de e new palavras-chave.
Produzir exemplo
Demonstra a palavra-chave rendimento para filtrar itens em uma coleção.
Exemplos intermediário e Avançado Exemplo atributos
Mostra como criar classes de atributo personalizado, usá-los em código, e consultá-los através de reflexão.
Exemplo parte 1 Interop COM
Mostra como usar C# para interoperar com objetos COM.
Exemplo parte 2 Interop COM
Mostra como um servidor use um C# com um cliente com C++.
Exemplo bibliotecas
Mostra como usar opções do compilador para criar uma DLL de vários arquivos de origem; além disso, como usar a biblioteca em outros programas.
Exemplo anulável
Demonstra tipos de valores que podem ser definidos como nulo.
Exemplo BD OLE
Demonstra como usar um banco de dados do Microsoft Access do C#. Ele mostra como você pode criar um DataSet e adicionar tabelas a ela a partir de um banco de dados.
Visual C# Consolidado
302
Exemplo tipos parcial Demonstra como classes e estruturas podem ser definidas em vários arquivos código fonte-C#. Plataforma Invoke exemplo
Mostra como chamar exportadas funções DLL do C#.
Exemplo de segurança
Discute a segurança do .NET Framework e mostra duas maneiras de modificar as permissões de segurança em C#: Usando classes de permissão e atributos de permissão.
Segmentação de exemplo
Demonstra várias atividades do segmento, como criando e executando um segmento, sincronizando segmentos, interagir entre segmentos, e usando um pool de segmentos.
Exemplo de código não seguros
Mostra como usar ponteiros.
Exemplo de documentação XML
Mostra como a documentar código usando XML.
Exemplo World de saudação Download sample Este Exemplo mostra várias versões de um programa hello world em C#. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir os arquivos de Exemplo no Solution Explorer 5.
Clique em Download Sample. A caixa de mensagem Download de arquivo será exibida.
6.
Clique em Open e, na coluna esquerda da pasta CEP, clique em Extract all files. O Extraction Wizard abre.
7.
Clique em Next. Você pode mudar a pasta os arquivos serão extraídos para, ou clique em Next novamente.
8.
Certifique-se de que a Show extracted files caixa de seleção esteja marcada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz a solução do projeto não é confiável. Clique OK para continuar. Para criar e executar os exemplos hello world no Visual Studio
Visual C# Consolidado
303
17. Abra a solução (HelloWorld.sln). 18. No Solution Explorer, clique com o projeto HelloWorld1, e clique em Set as StartUp Project. 19. No menu Debug, clique em Start Without Debugging. 20. Pressione qualquer tecla para fechar HelloWorld1. 21. No Solution Explorer, clique com o projeto HelloWorld2, e clique em Set as StartUp Project. 22. No menu Debug, clique em Start Without Debugging. 23. Pressione qualquer tecla para fechar HelloWorld2. 24. No Solution Explorer, clique com o projeto HelloWorld3, e clique em Set as StartUp Project. 25. No Solution Explorer, clique com o projeto HelloWorld3, e clique em Properties. 26. Abra a Configuration Properties pasta, e clique em Debug. 27. Na Command Line Arguments propriedade, tipo A B C D e clique em OK. 28. No menu Debug, clique em Start Without Debugging. 29. Pressione qualquer tecla para fechar HelloWorld3. 30. No Solution Explorer, clique com o projeto HelloWorld4, e clique em Set as StartUp Project. 31. No menu Debug, clique em Start Without Debugging. 32. Pressione qualquer tecla para fechar HelloWorld4. Para criar e executar os exemplos hello world a partir da linha de comando 6.
Use o Change Directory comando para alterar para o diretório HelloWorld.
7.
Digite o seguinte: cd HelloWorld1 csc Hello1.cs Hello1
8.
Digite o seguinte: cd ..\HelloWorld2 csc Hello2.cs Hello2
9.
Digite o seguinte: cd ..\HelloWorld3 csc Hello3.cs Hello3 A B C D
10. Digite o seguinte: cd ..\HelloWorld4 csc Hello4.cs Hello4
Exemplo de parâmetros da linha de comando Download sample Este Exemplo mostra como a linha de comando pode ser acessada e duas maneiras de acessar a matriz de parâmetros de linha de comando. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
Visual C# Consolidado
304
código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos parâmetros de linha de comando no Visual Studio 7.
No Solution Explorer, clique com o projeto CmdLine1, e clique em Set as StartUp Project.
8.
No Solution Explorer, clique com o projeto, e clique em Properties.
9.
Abra a Configuration Properties pasta, e clique em Debug.
10. Na propriedade Command Line Arguments, digite os parâmetros da linha de comando, e clique em OK. (Consulte o tutorial para obter um exemplo.) 11. No menu Debug, clique em Start Without Debugging. 12. Repita as etapas anteriores para CmdLine2. Para criar e executar os exemplos parâmetros de linha de comando a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório CmdLine1.
6.
Digite o seguinte: csc cmdline1.cs cmdline1 A B C
7.
Use o Change Directory comando para alterar para o diretório CmdLine2.
8.
Digite o seguinte: csc cmdline2.cs cmdline2 John Paul Mary
Exemplo matrizes Download sample Este Exemplo descreve e mostra como matrizes funcionam em C#. Para obter mais informações, consulte Matrizes (Guia de programação do C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
Visual C# Consolidado
305
código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo matrizes no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo matrizes a partir da linha de comando Digite o seguinte no prompt de comando:
•
csc arrays.cs arrays
Exemplo propriedades Download sample Este Exemplo mostra como propriedades são uma parte integral da C# linguagem de programação. Ele demonstra como propriedades são declaradas e usados. Consulte Propriedades Para obter mais informações. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente.
Visual C# Consolidado
306
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish. Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos propriedades no Visual Studio 4.
No Solution Explorer, clique com o projeto pessoa e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para shapetest.
Para criar e executar os exemplos Propriedades a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório pessoa.
6.
Digite o seguinte: csc person.cs person
7.
Use o Change Directory comando para alterar para o diretório shapetest.
8.
Digite o seguinte: csc abstractshape.cs shapes.cs shapetest.cs shapetest
Exemplo bibliotecas Download sample Este Exemplo mostra como criar e usar uma DLL em C#. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo bibliotecas no Visual Studio
Visual C# Consolidado
307
7.
No Solution Explorer, clique com o projeto FunctionTest, e clique em Set as StartUp Project.
8.
No Solution Explorer, clique com o projeto FunctionTest, e clique em Properties.
9.
Abra a Configuration Properties pasta e clique em Debug.
10. Na propriedade Command Line Arguments, insira 3 5 10. 11. Clique em OK. 12. No menu Debug, clique em Start Without Debugging. Isso automaticamente criar a biblioteca em funções e executar o programa. Para criar e executar o Exemplo bibliotecas a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório funções.
6.
Digite o seguinte: csc /target:library /out:Functions.dll Factorial.cs DigitCounter.cs
7.
Use o Change Directory comando para alterar para o diretório FunctionTest.
Exemplo de versão Download sample Este Exemplo demonstra versão em C# através do uso de e new palavras-chave. o override Versão ajuda manter a compatibilidade entre classes base e derivados como eles evoluir. Para obter informações adicionais, consulte Versão com o substituição e palavras-chave new (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
Visual C# Consolidado
308
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo versão no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo versão a partir da linha de comando Digite o seguinte no prompt de comando:
•
csc versioning.cs versioning
Coleção Exemplo classes Download sample Este Exemplo mostra como a implementar uma classe coleção que pode ser usado com a foreach instrução. Para obter mais informações, consulte Classes coleção (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos classes coleção no Visual Studio 4.
No Solution Explorer, clique com o projeto CollectionClasses1 e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para CollectionClasses2.
Para criar e executar os exemplos classes coleção a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório CollectionClasses1.
6.
Digite o seguinte: csc tokens.cs tokens
Visual C# Consolidado
309
7.
Use o Change Directory comando para alterar para o diretório CollectionClasses2.
8.
Digite o seguinte: csc tokens2.cs tokens2
Exemplo Structs Download sample Este Exemplo apresenta a sintaxe e uso de estruturas. Ele também aborda as diferenças importantes entre classes e estruturas. Consulte Objetos, classes e Structs (guia de programação C#) Para obter mais informações. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Structs no Visual Studio 4.
No Solution Explorer, clique com o projeto Struct1 e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para Struct2.
Para criar e executar os exemplos Structs a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório Struct1.
6.
Digite o seguinte: csc struct1.cs struct1
7.
Use o Change Directory comando para alterar para o diretório Struct2.
8.
Digite o seguinte: csc struct2.cs struct2
Visual C# Consolidado
310
Exemplo indexadores Download sample Este Exemplo mostra como classes C# podem declarar indexadores para fornecer acesso semelhante matriz-às classes. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo Indexers no Visual Studio 6.
No Solution Explorer, clique com o projeto indexadores, e clique em Properties.
7.
Abra a Configuration Properties pasta, e clique em Debug.
8.
Na propriedade Command Line Arguments, insira ..\..\Test.txt.
9.
Clique em OK.
10. No menu Debug, clique em Start Without Debugging. Para criar e executar o Exemplo Indexers a partir da linha de comando 3.
Para compilar o programa de exemplo, digite o seguinte no prompt de comando: csc indexer.cs
O programa de Exemplo inverte os bytes em um arquivo fornecido como um argumento da linha de comando. Por exemplo, para reverter os bytes em Test.txt e ver o resultado, emitir os seguintes comandos: indexers Test.txt type Test.txt 4.
Para alterar o arquivo revertido para Normal, execute o programa no mesmo arquivo novamente.
Indexado Exemplo propriedades Download sample
Visual C# Consolidado
311
Este Exemplo mostra como classes C# podem declarar indexadas propriedades para representa uma coleção de tipos diferentes de itens semelhantes matriz-. Para obter mais informações, consulte Propriedades (Guia de programação do C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo indexado propriedades no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo indexado Propriedades a partir da linha de comando Digite o seguinte no prompt de comando:
•
csc indexedproperty.cs indexedproperty
Exemplo Conversions definidas pelo usuário Download sample Este Exemplo mostra como definir conversões de ou para classes ou estruturas, e como essas conversões são usados. Consulte Operadores de conversão (guia de programação C#) Para obter mais informações. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample.
Visual C# Consolidado
312
A File Download caixa de mensagem será exibida. 5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Conversions pelo usuário no Visual Studio 4.
No Solution Explorer, clique com o projeto Conversion1 e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para Conversion2.
Para criar e executar os exemplos Conversions pelo usuário a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório Conversion1.
6.
Digite o seguinte: csc conversion.cs conversion
7.
Use o Change Directory comando para alterar para o diretório Conversion2.
8.
Digite o seguinte: csc structconversion.cs structconversion
Exemplo generics (C#) Download sample (http://download.microsoft.com/download/9/A/6/9A639BEE-F7B0423D-BFFD-4356299205D8/Generics.zip.exe) Este Exemplo mostra como criar uma classe personalizada lista genérico com um parâmetro único tipo, e como implementá IEnumerable Para ativar foreach iteração através do conteúdo da lista. O Exemplo também mostra como código de cliente cria uma instância da classe, especificando um argumento Tipo, e como restrições sobre o parâmetro type ativar operações adicionais a serem executadas sobre os argumentos Tipo. Para obter um Exemplo de uma classe a coleção genérica que implementa um bloco do iterador, consulte COMO: Criar um bloco iterador para uma lista genérica (Guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample.
Visual C# Consolidado
313
A File Download caixa de mensagem será exibida. 5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo Generics no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo Generics a partir da linha de comando Digite o seguinte no prompt de comando:
•
csc generics.cs generics Comentários Este Exemplo é fornecido para fins de demonstração e não se destina a ser usado sem modificações no código de produção. Para código de qualidade de produção, ele é recomendável que você usar as classes coleção no espaço para nome System.Collections.Generic sempre que possível.
Exemplo Overloading do operador Download sample Este Exemplo demonstra classes definidas pelo usuário como poderá sobrecarregar operadores. Consulte Operadores C# Para obter mais informações. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Visual C# Consolidado
314
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Overloading operador no Visual Studio 4.
No Solution Explorer, clique com o projeto complexo e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para Dbbool.
Para criar e executar os exemplos operador Overloading a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório complexo.
6.
Digite o seguinte: csc complex.cs complex
7.
Use o Change Directory comando para alterar para o diretório Dbbool.
8.
Digite o seguinte: csc dbbool.cs dbbool
Exemplo representantes Download sample Este Exemplo demonstra os tipos de representante. Ele mostra como para mapear delegados para estáticos e métodos da instância, e como combiná-las para criar representantes de difusão seletiva. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos representantes no Visual Studio
Visual C# Consolidado
315
4.
No Solution Explorer, clique com o projeto Delegates1, e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para Delegates2.
Para criar e executar os exemplos representantes a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório Delegates1.
6.
Digite o seguinte: csc bookstore.cs bookstore
7.
Use o Change Directory comando para alterar para o diretório Delegates2.
8.
Digite o seguinte: csc compose.cs compose
Exemplo eventos Download sample Este Exemplo mostra como a declarar, chamar, e configurar eventos em C#. Para obter mais informações, consulte Eventos (Guia de programação do C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos eventos no Visual Studio 4.
No Solution Explorer, clique com o projeto Events1, e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para Events2.
Para criar e executar os exemplos eventos a partir da linha de comando
Visual C# Consolidado
316
5.
Use o Change Directory comando para alterar para o diretório Events1.
6.
Digite o seguinte: csc events1.cs events1
7.
Use o Change Directory comando para alterar para o diretório Events2.
8.
Digite o seguinte: csc events2.cs events2
Exemplo de implementação de interface explícita Download sample Este Exemplo demonstra como explicitamente implementar membros de interface e como acessar esses participantes a partir de ocorrências interface. Para informações de plano de fundo, consulte Interfaces (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Explicit implementação interface no Visual Studio 4.
No Solution Explorer, clique com o projeto ExplicitInterface1 e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para ExplicitInterface2.
Para criar e executar os exemplos Explicit implementação interface a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório ExplicitInterface1.
6.
Digite o seguinte: csc explicit1.cs explicit1
7.
Use o Change Directory comando para alterar para o diretório ExplicitInterface2.
Visual C# Consolidado
317
8.
Digite o seguinte: csc explicit2.cs explicit2
Exemplo dos Métodos condicional Download sample Este Exemplo demonstra condicionais métodos, que fornecem um poderoso mecanismo pelo qual chamadas para métodos podem ser incluídos ou omitido dependendo se um símbolo é definido. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo métodos condicional no Visual Studio 7.
No Solution Explorer, clique com o projeto e clique em Properties.
8.
Abra a pasta Propriedades de configuração, e clique em Debug.
9.
Defina a Command Line Arguments propriedade para A B C.
10. Na pasta Propriedades de configuração, clique em Build. 11. Modificar a Conditional Compilation Constants propriedade. Por exemplo, adicionar ou excluir Debug. Clique em OK. 12. No menu Debug, clique em Start Without Debugging. Para criar e executar o Exemplo métodos condicional a partir da linha de comando •
Para incluir o método condicional, compilar e execute o programa de exemplo, digitando o seguinte no prompt de comando: csc CondMethod.cs tracetest.cs /d:DEBUG tracetest A B C
Exemplo de documentação XML Download sample
Visual C# Consolidado
318
Este Exemplo mostra como usar XML ao documento código. Consulte Comentários de documentação XML (Guia de programação C#) Para obter informações adicionais. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar o Exemplo documentação XML no Visual Studio 5.
No Solution Explorer, clique com o projeto e clique em Properties.
6.
Abra a pasta Propriedades de configuração e clique em Build.
7.
Defina a propriedade arquivo documentação XML como XMLsample.xml.
8.
No menu Build, clique em Build. O arquivo de saída XML poderá ser no diretório de depuração.
Para criar o Exemplo documentação XML a partir da linha de comando 3.
Para gerar a documentação XML de exemplo, digite o seguinte no prompt de comando: csc XMLsample.cs /doc:XMLsample.xml
4.
Para ver o XML gerado, emita o seguinte comando: type XMLsample.xml
Plataforma Invoke Exemplo Download sample Este Exemplo demonstra como chamar plataforma chama (funções exportadas DLL) do C#. Consulte Interoperabilidade (guia de programação C#) Para obter mais informações. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
Visual C# Consolidado
319
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Platform Invoke no Visual Studio 4.
No Solution Explorer, clique com o projeto PinvokeTest e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para Marshal e PInvoke.
Para criar e executar os exemplos Platform Invoke a partir da linha de comando 7.
Use o Change Directory comando para alterar para o diretório PinvokeTest.
8.
Digite o seguinte: csc PinvokeTest.cs PinvokeTest
9.
Use o Change Directory comando para alterar para o diretório Marshal.
10. Digite o seguinte: csc Marshal.cs Marshal 11. Use o Change Directory comando para alterar para o diretório PInvoke. 12. Digite o seguinte: csc logfont.cs pinvoke.cs pinvoke
Exemplo parte 1 Interop COM Download sample Este Exemplo demonstra como um programa C# pode interoperar com um componente COM não gerenciado. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
Visual C# Consolidado
320
código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos com Interop parte 1 no Visual Studio 8. 9.
No Solution Explorer, clique com o projeto Interop1, e clique em Set as StartUp Project. No Solution Explorer, clique com o projeto Interop1, e clique em Properties.
10. Abra a Configuration Properties pasta, e clique em Debug. 11. Na propriedade argumentos de linha de comando, digite um arquivo AVI como c:\winnt\clock.avi. 12. Clique em OK. 13. No menu Debug, clique em Start Without Debugging. 14. Repita as etapas anteriores para Interop2. Se o QuartzTypeLib.dll incluído com Interop1 está desatualizado 7.
No Solution Explorer, abrir References para Interop1.
8.
Clique com o botão direito do mouse QuartzTypeLib e, clique em Remove.
9.
Clique com o botão direito do mouse References e, clique em Add Reference.
10. Na guia COM, selecione o componente denominado, " biblioteca Tipo de Controle ActiveMovie ". 11. Clique em Select e, clique em OK. 12. Recrie Interop1. Observação Adicionando uma referência para o componente faz a mesma coisa que chamar TLBIMP na linha de comando para criar QuartzTypeLib.dll (como mostrado abaixo). Para criar e executar os exemplos com Interop Parte 1 a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório Interop1.
Use o Change Directory comando para alterar para o diretório Interop2.
8.
Digite o seguinte: csc interop2.cs interop2 %windir%\clock.avi
Exemplo parte 2 Interop COM Download sample Este Exemplo demonstra usando um servidor C# com um cliente com C++. Observação É preciso instalar para compilar Este Exemplo Visual C++.
Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo 2 Part Interop COM no Visual Studio 6.
No Solution Explorer, clique com o projeto COMClient, e clique em Properties.
7.
Abra a Configuration Properties pasta, e clique em Debug.
8.
Na propriedade Command Line Arguments, digite um nome.
9.
Clique em OK.
10. No menu Debug, clique em Start Without Debugging.
Visual C# Consolidado
322
Para criar e executar o Exemplo 2 Part Interop COM a partir da linha de comando 6. 7.
Use o Change Directory comando para alterar para o diretório COMInteropPart2\COMClient. Copie o código do servidor C# para o diretório COMClient: copy ..\CSharpServer\CSharpServer.cs
8.
Compilar o servidor: csc /target:library CSharpServer.cs regasm CSharpServer.dll /tlb:CSharpServer.tlb
9.
Compilar o cliente (verifique se as variáveis Caminho e ambiente são definidas corretamente com vcvars32.bat):: cl COMClient.cpp
10. Execute o cliente: COMClient friend
Exemplo atributos Download sample Este Exemplo demonstra como criar classes de atributo personalizado, usá-los em código, e consultá-los através de reflexão. Para obter mais informações sobre atributos, consulte Atributos (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo atributos no Visual Studio •
No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo atributos a partir da linha de comando •
Digite o seguinte no prompt de comando:
Visual C# Consolidado
323
csc AttributesTutorial.cs AttributesTutorial
Exemplo de segurança Download sample Este Exemplo demonstra como modificar as permissões de segurança através de classes de permissão e atributos de permissão. Para obter informações adicionais, consulte Segurança (guia de programação C#). Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos de segurança no Visual Studio 4.
No Solution Explorer, clique com o projeto Security1 e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para Security2 e Security3.
Para criar e executar os exemplos de segurança a partir da linha de comando 7.
Use o Change Directory comando para alterar para o diretório Security1.
8.
Digite o seguinte: csc ImperativeSecurity.cs ImperativeSecurity
9.
Use o Change Directory comando para alterar para o diretório Security2.
10. Digite o seguinte: csc DeclarativeSecurity.cs DeclarativeSecurity 11. Use o Change Directory comando para alterar para o diretório Security3. 12. Digite o seguinte: csc SuppressSecurity.cs SuppressSecurity
Visual C# Consolidado
324
Segmentação de Exemplo Download sample Este Exemplo demonstra as seguintes técnicas segmentação. Consulte Segmentação (guia de programação C#) Para obter mais informações. •
Criar, iniciar, e Finalizando um segmento
•
Usando um pool de segmentos
•
Segmento Sincronização e interação Observação de segurança
Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos Threading no Visual Studio 4.
No Solution Explorer, clique com o projeto ThreadStartStop e clique em Set as StartUp Project.
5.
No menu Debug, clique em Start Without Debugging.
6.
Repita as etapas anteriores para ThreadPool, e ThreadSync.
Para criar e executar os exemplos Threading a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório segmentos.
6.
Digite o seguinte: cd ThreadStartStop csc ThreadStartStop.cs ThreadStartStop
7.
Digite o seguinte: cd ..\ThreadPool csc ThreadPool.cs ThreadPool
8.
Digite o seguinte: cd ..\ThreadSync csc ThreadSync.cs ThreadSync
Visual C# Consolidado
325
Exemplo de código não seguros Download sample Este Exemplo demonstra como usar código não gerenciado (código usando ponteiros) no C#. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar os exemplos UNSAFE código no Visual Studio 11. No Solution Explorer, clique com o projeto FastCopy, e clique em Set as StartUp Project. 12. No menu Debug, clique em Start Without Debugging. 13. No Solution Explorer, clique com o projeto ReadFile, e clique em Set as StartUp Project. 14. No Solution Explorer, clique com o projeto ReadFile, e clique em Properties. 15. Abra a pasta Propriedades de configuração, e clique em Debug. 16. Na propriedade argumentos da linha de comando, insira ..\..\ReadFile.cs. 17. Clique em OK. 18. No menu Debug, clique em Start Without Debugging. 19. No Solution Explorer, clique com o projeto PrintVersion, e clique em Set as StartUp Project. 20. No menu Debug, clique em Start Without Debugging. Para criar e executar os exemplos de código UNSAFE a partir da linha de comando 5.
Use o Change Directory comando para alterar para o diretório UNSAFE.
6.
Digite o seguinte: cd FastCopy csc FastCopy.cs /unsafe FastCopy
Visual C# Consolidado
326
7.
Digite o seguinte: cd ..\ReadFile csc ReadFile.cs /unsafe ReadFile ReadFile.cs
8.
Digite o seguinte: cd ..\PrintVersion csc PrintVersion.cs /unsafe PrintVersion
Exemplo BD OLE Download sample Este Exemplo demonstra como usar um banco de dados do Microsoft Access do C#. Ele mostra como você pode criar um DataSet e adicionar tabelas a ela a partir de um banco de dados. O banco de dados BugTypes.MDB usado no programa de Exemplo é um arquivo.mdb do Microsoft Access 2000. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo de banco de dados OLE no Visual Studio •
No menu Debug, clique em Start Without Debugging. Observação
Se você estiver criando a solução no modo Release, copie BugTypes.mdb para a pasta \bin\release. Para criar e executar o Exemplo OLE DB a partir da linha de comando •
Digite o seguinte no prompt de comando: csc oledbsample.cs oledbsample
Visual C# Consolidado
327
Produzir Exemplo Download sample Este Exemplo mostra como criar uma classe lista que implementa IEnumerable e palavra-chave yield Para ativar foreach iteração através do conteúdo da lista. Duas propriedades são definidas, um retornar os números ímpares, o outro retornar os números pares. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo YIELD código no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo YIELD código a partir da linha de comando 3.
Use o Change Directory (cd) comando para alterar para o Yield Diretório.
4.
Digite o seguinte: csc Yield.cs Yield
Anônimo Exemplo representantes Download sample Este Exemplo demonstra usar um representante anônimo para calcular um bônus do salário de um funcionário. Usar um representante anônimo simplifica o programa porque não é necessário para definir um método separado. Os dados para cada funcionário são armazenados em um objeto que contém detalhes pessoais, bem como um representante que referencia o algoritmo necessário para calcular o bônus. Definindo o algoritmo por meio de um representante, o mesmo método pode ser usado para executar o cálculo do bônus, independentemente de como ele é realmente calculado. De anotação, uma variável local, multiplicador, também se torna uma variável externo capturado porque ele é mencionado em um cálculo delegado.
Visual C# Consolidado
328
Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo de código AnonymousDelegates no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo de código AnonymousDelegates a partir da linha de comando 3. 4.
Use o Change Directory (cd) comando para alterar para o diretório AnonymousDelegates. Digite o seguinte: csc AnonymousDelegates.cs AnonymousDelegates
Exemplo tipos parcial Download sample Este Exemplo demonstra o uso de tipos parciais que permitem class ou struct para ser definidos em dois ou mais arquivos C#. Isso permite que vários programadores para trabalhar em partes diferentes de uma classe em paralela, e para aspectos diferentes de uma classe complexo a serem mantidos em arquivos separados. Observação de segurança Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample.
Visual C# Consolidado
329
A File Download caixa de mensagem será exibida. 5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo de código PartialTypes no Visual Studio No menu Debug, clique em Start Without Debugging.
•
Para criar e executar o Exemplo de código PartialTypes a partir da linha de comando 3.
Use o Change Directory (cd) comando para alterar para o PartialTypes Diretório.
4.
Digite o seguinte: csc PartialTypes.cs PartialTypes
Exemplo anulável Download sample Este Exemplo demonstra o uso de tipos anuláveis. Esse recurso permite que tipos de valores para que um estado não inicializada, ou vazio, semelhante a como tipos de referência podem ser definidos como null. Este Observação de segurança código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o código do Exemplo deve ser usado para fins diferente da maneira desejada Para abrir o arquivo de Exemplo no Solution Explorer 4.
Clique em Download Sample. A File Download caixa de mensagem será exibida.
5.
Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all files. O Extraction Wizard abre.
6.
Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique em Next novamente. Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique em Finish.
Clique duas vezes o Exemplo na Arquivo.sln. A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de segurança que diz o local de solução não é confiável. Clique OK para continuar. Para criar e executar o Exemplo Nullable código no Visual Studio
Visual C# Consolidado
330
3. 4.
Abra Nullable.sln, o arquivo de solução, o clicando duas vezes no arquivo no Windows Explorer, ou clicando Open no menu File. No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo de código Nullable a partir da linha de comando 3.
Use o Change Directory (cd) comando para alterar para o diretório Nullable.
4.
Digite o seguinte: csc Nullable.cs Nullable
Visual C# Consolidado
331
Como Fazer em C# http://msdnwiki.microsoft.com/pt-br/mtpswiki/ms186211.aspx Como Fazer é sua porta de entrada para tópicos-chave baseados em tarefas sobre programação e desenvolvimento de aplicativos em C#. As categorias essenciais sobre o que você pode fazer com C# estão listadas neste tópico. Os links fornecem referências para páginas de ajuda importantes baseadas em procedimento. A Linguagem C# Especificação da Linguagem C# ... Threading… Genéricos... Trechos de Código… Exemplos… mais O Framework .NET Entrada e Saída em Arquivos… Strings… Coleções… Serialização… Componentes… Módulos (assemblies) e Domínios de Aplicativo… mais Aplicativos do Windows Criando Aplicativos do Windows… Controles…Windows Forms… Desenhando… mais Páginas Web e Web Services Pages Web do ASP.NET… XML Web Services… mais Depuração Usando o Depurador VS… Classe Trace .Framework NET… Depuração de Transações SQL… mais Accesso a Dados Conectando a Fontes de Dados… O SQL Server... Vinculação de Dados… mais Criando Classes Class Designer... Trabalhando com Classes e Outros Tipos... Criando e Modificando Membros-tipo... Linhas-mestras para a Criação de Bibliotecas de Classes… mais Segurança Segurança no Acesso ao Código… Práticas Recomendadas de Política de Segurança… Conjuntos de Permissões… mais Programação do Office Programação do Office… Controles… Word… Excel… mais Dispositivos Inteligentes
Visual C# Consolidado
332
O que há de novo em Projetos para Dispositivos Inteligentes... Programação para Dispositivos Inteligentes... Depuração em Dispositivos Inteligentes... mais Implantação ClickOnce… O Windows Installer
Visual C# Consolidado
333
Linguagem C# (como eu faço em C#) Esta página possui links para ajudá-lo com tarefas frequentemente executadas na linguagem C#. Para ver outras categorias de tarefas populares abordadas na ajuda, consulte Como eu faço em C#. A linguagem C# O que há de novo na linguagem e no compilador C# 2.0 Contém informações sobre os novos recursos, incluindo classes genéricas, iteradores, métodos anônimos e tipos parciais. Usando o Starter Kit para C# Explica como carregar e compilar um Starter Kit no Visual C#. Especificação da linguagem C# Ponteiros para a versão mais recente da especificação em formato Microsoft Word. Linha de comando Main() e argumentos de linha de comando (Guia de programação C#) Explica o método Main, o ponto de entrada do seu programa, onde você cria objetos e chama outros métodos. Só pode haver um ponto de entrada em um programa C#. COMO: Acessar argumentos de linha de comando usando foreach (Guia de programação C#) Fornece um exemplo de código que mostra como acessar os parâmetros da linha de comando. COMO: Exibir argumentos de linha de comando (Guia de programação C#) Explica como exibir argumentos de linha de comando através do vetor de seqüências args. Main() retorna valores (Guia de programação C#) Explica os possíveis valores retornados pelo método principal. Classes e herança Base (Referência C#) Explica como especificar o construtor da classe base chamado ao criar instâncias de uma classe derivada. COMO: Saber as diferenças entre passar uma estrutura e passar uma referência de classe para um método (Guia de programação C#) Contém um exemplo de código que mostra que quando uma estrutura (struct) é passada para um método, uma cópia da estrutura é passada, mas quando uma instância de classe é passada, uma referência é passada.
Visual C# Consolidado
334
Construtores de instância (Guia de programação C#) Explica construtores de classe e herança. Propriedades COMO: Declarar e usar propriedades de leitura/escrita (Guia de programação C#) Contém um exemplo que mostra como declarar e usar propriedades de leitura/escrita. COMO: Definir propriedades abstratas (Guia de programação C#) Contém um exemplo de código que mostra como definir propriedades abstratas. Eventos COMO: Criar um controle que responde a eventos (Guia de programação C#) Contém um exemplo de código que mostra uma classe, ListWithChangedEvent, que é semelhante à classe padrão ArrayList mas também chama um evento Changed sempre que o conteúdo da lista é alterado. COMO: Criar eventos que estejam de acordo com as diretrizes do .NET Framework (Guia de programação C#) Contém um exemplo que cria um controle que responde a eventos, seguindo as orientações das .NET Framework Guidelines. COMO: Declarar um evento em uma interface e implementá-lo em uma classe (Guia de programação C#) Mostra que é possível declarar um evento em uma interface e implementá-lo em uma classe. COMO: Usar um dicionário para armazenar instâncias de eventos (Guia de programação C#) Explica como usar uma tabela de hash para armazenar as instâncias de eventos. COMO: Implementar duas interfaces que possuam um evento com o mesmo nome (Guia de programação C#) Explica a situação onde você implementa duas interfaces, cada uma com um evento com o mesmo nome. Nesse caso, você deve usar uma propriedade de evento explicitamente de implementação. COMO: Criar manipuladores de evento no Visual C# Code Editor (Guia de programação C#) Oferece uma maneira fácil para criar manipuladores de eventos para seus Windows Forms quando no modo de design. A alternativa é exibir o código fonte no modo de exibição Source e adicionar o manipulador de eventos no código. Interfaces COMO: Implementar explicitamente membros de uma interface (Guia de programação C#) Mostra como declarar uma classe que explicitamente implementa uma interface e como acessar seus membros através da instância da interface.
Visual C# Consolidado
335
COMO: Implementar explicitamente membros de uma interface com herança (Guia de programação C#) Fornece um exemplo que exibe as dimensões de uma caixa em unidades métrica e do sistema inglês. Classes Genéricas Uma introdução ao Generics C# Descreve como classes genéricas permitem que você defina classes de coleção que são fortemente tipadas (Type-Safe). Você implementa a classe genérica somente uma vez, mas você pode declará-la e usá-la com qualquer tipo. Classes genéricas no .NET Framework Explica os recursos e o uso do novo conjunto de coleções genéricas no espaço de nomes System.Collections.Generic. A palavra-chave default em código fonte "genérico" (Guia de programação C#) Fornece um exemplo de código que demonstra como usar a palavra-chave default para tipo parâmetros. Métodos genéricos (Guia de programação C#) Apresenta a sintaxe para declarar um método genérico. E também mostra um exemplo de como usar métodos genéricos em um aplicativo. Restrições em parâmetros de tipo (Guia de programação C#) Mostra como restringir parâmetros de tipo para permitir o acesso a métodos e propriedades dos tipos usados para instanciar a classe genérica. Representantes genéricos (Guia de programação C#) Contém a sintaxe para declarar representantes (delegates) genéricos. E também inclui comentários importantes sobre como instanciar e usar representantes genéricos, assim como exemplos de código. Espaços de nomes COMO: Usar o qualificador de espaço de nomes Alias (Guia de programação C#) Discute a capacidade de acessar um membro no espaço de nomes global quando o membro pode estar oculto por outra entidade com o mesmo nome. Iteradores COMO: Criar um bloco iterador para uma lista genérica (Guia de programação C#) Fornece um exemplo onde um vetor de inteiros é usado para criar a lista SampleCollection. Um laço for itera através da coleção e produz o valor de cada item. Depois um laço foreach é usado para exibir os itens da coleção. COMO: Criar um bloco iterador para uma lista genérica (Guia de programação C#)
Visual C# Consolidado
336
Fornece um exemplo onde uma classe genérica Stack implementa uma interface genérica IEnumerator. Um vetor de T tipo é declarado e a ele são atribuídos valores usando o método Push. No método GetEnumerator, os valores do vetor são retornados usando a instrução de retorno yield. Representantes (Delegates) COMO: Combinar representantes (Representantes Multicast) (Guia de programação C#) Fornece um exemplo que demonstra como compor representantes de difusão seletiva. COMO: Declarar, instanciar e usar um representante (Guia de programação C#) Fornece um exemplo que ilustra como declarar, criar e usar um representate (delegate). Sobrecarga de operador COMO: Usar sobrecarga de operador para criar uma classe para números complexos (Guia de programação C#) Mostra como você pode utilizar sobrecarga de operador para criar uma classe para números complexos chamada Complex e que define adição de complexos. Interoperabilidade COMO: Usar interoperabilidade COM para verificar ortografia usando o Word (Guia de programação C#) Este exemplo ilustra como usar o verificador ortográfico do Word em um aplicativo C#. COMO: Usar interoperabilidade COM para criar uma planilha do Excel (Guia de programação C#) Este exemplo ilustra como abrir uma planilha já existente do Excel em C# usando funcionalidades de interoperabilidade COM no .NET Framework. COMO: Usar código gerenciado como um suplemento de automação para o Excel (Guia de programação C#) Este exemplo ilustra como criar um suplemento C# para calcular taxa de imposto de renda em uma célula em uma planilha do Excel. COMO: Usar serviços de chamada da plataforma para reproduzir um arquivo WAVE (Guia de programação C#) Este exemplo ilustra como usar serviços de chamada da plataforma para reproduzir um arquivo de som wave na plataforma Windows. Código não gerenciado COMO: Usar ponteiros para copiar um vetor de bytes (Guia de programação C#) Mostra como usar ponteiros para copiar bytes de um vetor para outro, usando ponteiros. COMO: Usar a função ReadFile do Windows (Guia de programação C#) Mostra como chamar a função ReadFile do Windows, que requer o uso de um contexto não gerenciado pois o buffer de leitura requer um ponteiro como parâmetro.
Visual C# Consolidado
337
Lidando com threads Usando segmentos e Threading Fornece uma lista de tópicos que abordam a criação e o gerenciamento de threads gerenciados e como evitar conseqüências não intencionais. COMO: Criar e terminar threads (Guia de programação C#) Fornece um exemplo que demonstra como criar e iniciar uma thread e mostra a interação entre duas threads em execução simultânea dentro do mesmo processo. COMO: Sincronizar uma thread Produtor e uma thread Consumidor (Guia de programação C#) Fornece um exemplo que mostra como sincronização pode ser feita usando a palavrachave lock de C# e o método Pulse do objeto Monitor. COMO: Usar um pool de threads (Guia de programação C#) Explica um exemplo que mostra como usar um pool de threads. Seqüências de caracteres COMO: Pesquisar em seqüências de caracteres utilizando expressões regulares (Guia de programação C#) Explica como a classe Regex pode ser usada para procurar em seqüências. Essas pesquisas podem variar em complexidade de muito simples a fazer uso total de expressões regulares. COMO: Unir várias seqüências de caracteres (Guia de programação C#) Contém um exemplo que demonstra como unir várias seqüências de caracteres. COMO: Pesquisar em seqüências de caracteres utilizando métodos de String (Guia de programação C#) Contém um exemplo de código que demonstra como usar métodos de String para procurar em uma seqüência. COMO: Analisar seqüências usando o método Split (Guia de programação C#) Contém um exemplo de código que demonstra como uma seqüência pode ser analisada usando o método System.String.Split. Atributos COMO: Criar uma união C/C++ usando atributos (Guia de programação C#) Contém um exemplo que usa o atributo serializable para aplicar uma característica específica a uma classe. Trabalhando com DLLs COMO: Criar e usar DLLs em C# (Guia de programação C#) Demonstra a criação e o uso de uma DLL, usando um cenário de exemplo.
Visual C# Consolidado
338
Módulos (assemblies) COMO: Determinar se um arquivo é um módulo (assembly) (Guia de programação C#) Contém um exemplo que testa uma DLL para verificar se ela é um módulo (assembly). COMO: Carregar e descarregar módulos (assemblies) (Guia de programação C#) Explica como é possível carregar módulos (assemblies) específicos no domínio de aplicação atual em tempo de execução. COMO: Compartilhar um módulo (assembly) com outros aplicativos (Guia de programação C#) Explica como compartilhar um assembly com outros aplicativos. Domínios de aplicação Executar código em outro domínio de aplicação (Guia de programação C#) Mostra como executar um assembly que tenha sido carregado de outro domínio de aplicação. COMO: Criar e usar um domínio de aplicação (Guia de programação C#) Mostra como a sobrecarga de operador pode ser usada para implementar um tipo lógico tri-valorado. Amostras Exemplos no Visual C# Contém links para abrir ou copiar arquivos dos exemplos que vão de Exemplo de Hello World até Exemplo de classes genéricas (C#).
Visual C# Consolidado
339
O que há de novo na C# 2.0 idioma e Compiler Com o lançamento do Visual Studio 2005, a linguagem C# foi atualizada para versão 2.0, que oferece suporte os seguintes recursos novos: O compilador C# apresenta os seguintes adições e alterações para esta versão: Opção /errorreport Pode ser usado para relatar erros de compilador interno à Microsoft através da Internet. Opção /incremental Foi removido. e /keycontainer/KeyFile Opções Oferecer suporte à especificação chaves criptográficas. Opção /langversion Pode ser usado para especificar compatibilidade com uma versão específica do idioma. Opção /linkresource Contém opções adicionais. Opção /moduleassemblyname Permite que você se criar um.netmodule tipos de arquivo e acesso não-públicos em um conjunto existente. Opção /PDB Especifica o nome e local do arquivo.pdb. Opção /Platform Permite que você para arquiteturas Family (IPF) Itanium e x 64 de destino. Aviso # pragma Usado para desativar e ativar individuais avisos no código.
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.
Visual C# Consolidado
340
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.
Especificação da Linguagem C# As versões 1.2 e 2.0 das especificações da linguagem C# são a fonte autorizada de gramática e sintaxe C#. Elas contêm informações detalhadas sobre todos os aspectos da linguagem, incluindo muitos pontos não abordados na documentação do produto Visual C#. A especificação 1.2 discute recursos que foram adicionados para a linguagem antes do Visual C# 2005 e a especificação 2.0 discute recursos que foram adicionados para o Visual C# 2005. As especificações da linguagem C# estão disponíveis no formato Microsoft Word nos seguintes locais: •
No MSDN Online em http://msdn.microsoft.com/vcsharp/Programming/Language/default.aspx
•
No Visual Studio, na pasta VC#\Specifications\1033\ sob o diretório de instalação do seu Microsoft Visual Studio 2005 .
Se você não tiver o Microsoft Word instalado em seu computador, você pode visualizar, copiar e imprimir a versão do Word da especificação com o gratuito Palavra visualizador 2003. A especificação da linguagem C# também está disponível como um livro publicado pelo Addison Wesley.
Main() e argumentos de linha de comando (Guia de programação C#) O método Main é o ponto de entrada do seu programa, onde você cria objetos e chama outros métodos. Só pode haver um único ponto de entrada em um programa C#. CSharp class TestClass { static void Main(string[] args) { // Display the number of command line arguments: System.Console.WriteLine(args.Length); } }
Visão Geral •
O Main método é o ponto de entrada do seu programa, onde o controle de execução do programa inicia e termina.
•
Ele é declarado dentro de uma classe ou estrutura. Ele deve ser estático (static) e ele não deve ser público. (No exemplo acima, como não especificamos um modificador de acesso explicitamente, ele recebe o modificador de acesso padrão, que é (private) particular).
•
Ou ele pode retornar void ou então um tipo int.
•
O método Main pode ser declarado com ou sem parâmetros.
•
Parâmetros podem ser lidos como argumentos de linha de comando indexados a partir do zero.
•
Diferentemente C e C++, o nome do programa não é tratado como o primeiro argumento de linha de comando.
Visual C# Consolidado
341
COMO: Acessar argumentos de linha de comando usando foreach (Guia de programação C#) Outra abordagem para Iterando através da matriz é a usar a foreach instrução conforme mostrado no exemplo. A foreach instrução pode ser usada para iterar por uma matriz, uma classe Coleção .NET Framework, ou qualquer classe ou estrutura que implementa a IEnumerable interface. Exemplo Este exemplo demonstra como imprimi-los os argumentos de linha de comando usando foreach. C# // arguments: John Paul Mary
C# class CommandLine2 { static void Main(string[] args) { System.Console.WriteLine("Number of command line parameters = {0}", args.Length); foreach (string s in args) { System.Console.WriteLine(s); } } }
Saída Number of command line parameters = 3 John Paul Mary
COMO: Exibir argumentos de linha de comando (Guia de programação C#) Argumentos fornecidos para um executável na linha de comando são acessíveis através um parâmetro opcional para Main. Os argumentos são fornecidos na forma de uma matriz de seqüências. Cada elemento da matriz contém um argumento. Espaço White-entre argumentos é removido. Por exemplo, considere essas invocações de linha de comando de um executável fictícia: Entrada na linha de comando
Matriz de seqüências de caracteres passado para principal
executable.exe a b c
"a" "b" "c"
executable.exe one two
" um " " dois "
executable.exe “one two” three " dois " um " três " Exemplo Este exemplo exibe os argumentos de linha de comando passados para um aplicativo de linha de comando. O resultado mostrado é para a primeira entrada na tabela acima. C# class CommandLine { static void Main(string[] args) { // The Length property provides the number of array elements System.Console.WriteLine("parameter count = {0}", args.Length); for (int i = 0; i < args.Length; i++) { System.Console.WriteLine("Arg[{0}] = [{1}]", i, args[i]); } } }
Main() retorna valores (Guia de programação C#) O Main método pode ser do tipo void: C# static void Main() { //... }
Ele também pode retornar um int: C# static int Main() { //... return 0; }
Se o valor de retorno da Main não deve ser usado, seguida, retornar void permite que código ligeiramente mais simples. No entanto, retornar um inteiro permite que o programa para relacionar informações de status para outros programas ou scripts que chamar o executável. Um exemplo de usar o valor de retorno da Main é mostrado no exemplo a seguir. Exemplo Um arquivo em lotes, neste exemplo é usado para executar um programa e testar o valor a Main função de retorno. Quando um programa é executado no Windows, qualquer valor retornado da Main função é armazenado em uma variável de ambiente chamada ERRORLEVEL. Ao inspecionar a ERRORLEVEL variável, arquivos em lotes portanto podem determinar o resultado da execução. Tradicionalmente, um valor de retorno de zero indica execução com êxito. Abaixo é um programa muito simples que retorna zero da função Main. C# class MainReturnValTest { static int Main() { //... return 0; } }
Como este exemplo usa um arquivo em lotes, é melhor para compilar esse código a partir da linha de comando, conforme demonstrado no Como construir a partir da linha de comando:. Em seguida, um arquivo em lotes é usado para chamar o executável resultante do exemplo de código anterior. Porque o código retorna zero, o arquivo em lotes irá reportar êxito, mas se o código anterior é alterado para retornar um valor diferente de zero, e é então re-Compiled, subseqüente execução do arquivo em lotes indicará falha. rem test.bat @echo off MainReturnValueTest @if "%ERRORLEVEL%" == "0" goto good :fail echo Execution Failed echo return value = %ERRORLEVEL% goto end :good echo Execution Succeded echo return value = %ERRORLEVEL% goto end :end
Saída de exemplo Execution Succeded return value = 0
base (Referência do C#) Palavra-chave base é usada para acessar membros da classe base em uma classe derivada de: •
Chamar um método na classe base que tenha sido substituído por outro método.
Visual C# Consolidado
343
•
Especificar o construtor de classe base deve ser chamado ao criar instâncias da classe derivada.
Um acesso classe base é permitido somente em um construtor, um método da instância, ou um assessor propriedade da instância. Ele é um erro para usar a base palavra de dentro de um método estático. Exemplo Neste exemplo, dois a classe base, Person,. e a classe, Employee, tem um método chamado Getinfo derivado Usando a base palavra-chave, é possível para chamar o Getinfo método na classe base, de dentro da classe derivada. // keywords_base.cs // Accessing base class members using System; public class Person { protected string ssn = "444-55-6666"; protected string name = "John L. Malgraine"; public virtual void GetInfo() { Console.WriteLine("Name: {0}", name); Console.WriteLine("SSN: {0}", ssn); } } class Employee : Person { public string id = "ABC567EFG"; public override void GetInfo() { // Calling the base class GetInfo method: base.GetInfo(); Console.WriteLine("Employee ID: {0}", id); } } class TestClass { static void Main() { Employee E = new Employee(); E.GetInfo(); } }
Este exemplo mostra como para especificar o construtor de classe base chamado quando criar instâncias de uma classe derivada. // keywords_base2.cs using System; public class BaseClass { int num; public BaseClass() { Console.WriteLine("in BaseClass()"); } public BaseClass(int i) { num = i; Console.WriteLine("in BaseClass(int i)"); } public int GetNum() { return num; } } public class DerivedClass : BaseClass { // This constructor will call BaseClass.BaseClass() public DerivedClass() : base() { } // This constructor will call BaseClass.BaseClass(int i) public DerivedClass(int i) : base(i) { } static void Main() { DerivedClass md = new DerivedClass(); DerivedClass md1 = new DerivedClass(1); } }
Saída Name: John L. Malgraine SSN: 444-55-6666 Employee ID: ABC567EFG
Para obter exemplos adicionais, consulte Novo, virtual. e Substituir Saída in BaseClass() in BaseClass(int i)
Especificação da Linguagem C# Para obter mais informações, consulte as seções a seguir no Especificação da Linguagem C#: •
Classes base 1.6.3
•
Acesso 7.5.8 base
COMO: Saber as diferenças entre passar uma estrutura e passar uma referência de classe para um método (Guia de programação C#) Este exemplo mostra que Quando. é passado para um método, uma cópia da estrutura é passada, mas quando uma Classe instância é passada, uma referência é passada um struct
Visual C# Consolidado
344
A saída do exemplo a seguir mostra que somente o valor do campo de classe é alterado quando a instância de classe é passada para o ClassTaker método. O campo struct, no entanto, não altera, passando sua instância para o StructTaker método. Isso ocorre porque uma cópia da estrutura é passada para o StructTaker método, enquanto uma referência para a classe é passada para o ClassTaker método. Exemplo C# class TheClass { public string willIChange; } struct TheStruct { public string willIChange; } class TestClassAndStruct { static void ClassTaker(TheClass c) { c.willIChange = "Changed"; } static void StructTaker(TheStruct s) { s.willIChange = "Changed"; } static void Main() { TheClass testClass = new TheClass(); TheStruct testStruct = new TheStruct(); testClass.willIChange = "Not Changed"; testStruct.willIChange = "Not Changed"; ClassTaker(testClass); StructTaker(testStruct); System.Console.WriteLine("Class field = {0}", testClass.willIChange); System.Console.WriteLine("Struct field = {0}", testStruct.willIChange); } }
Saída Class field = Changed Struct field = Not Changed
Construtores de instância (Guia de programação C#) Construtores Instância são usados para criar e inicializar instâncias. O construtor de classe é invocado quando você criar um novo objeto, por exemplo: C# class CoOrds { public int x, y; // constructor public CoOrds() { x = 0; y = 0; } }
Observação Para maior clareza, essa classe contém membros de dados pública. Essa é uma prática de programação não recomendada porque ela permite que qualquer método em qualquer lugar em um programa irrestrito e unverified acesso ao funcionamento interno do objeto. Membros de dados geralmente deve ser particular, e devem ser acessados apenas por classe métodos e propriedades. Esse construtor é chamada sempre que um objeto baseado na classe CoOrds é criado. Um construtor como esta ocorrência, que tem sem argumentos, é chamada um construtor padrão. No entanto, geralmente é útil para fornecer construtores adicionais. Por exemplo, que pode adicionar um construtor para a CoOrds classe que permite que nós para especificar os valores iniciais para os membros de dados: C# // A constructor with two arguments: public CoOrds(int x, int y) { this.x = x; this.y = y; }
Isso permite CoOrd objetos a ser criado com padrão ou específicos valores iniciais, como este: C# CoOrds p1 = new CoOrds(); CoOrds p2 = new CoOrds(5, 3);
Visual C# Consolidado
345
Se uma classe não tem um construtor padrão, um é gerado automaticamente e valores padrão serão usados para inicializar os campos de objeto, por exemplo, é inicializada com 0. um Int Para obter mais informações sobre valores padrão, consulte Tabela de valores padrão (referência C#). Portanto, porque o CoOrds Construtor padrão de classe inicializa todos os membros de dados como zero, ele pode ser removido totalmente sem alterar como a classe funciona. Um exemplo completo usando vários construtores é fornecido no Exemplo 1 posteriormente contidas neste tópico, e um exemplo de um construtor gerado automaticamente é fornecido no Exemplo 2. Construtores instância podem ser usados para chamar as construtores da instância de classes base. O construtor de classe pode chamar o construtor da classe base através do Inicializador, da seguinte maneira: C# class Circle : Shape { public Circle(double radius) : base(radius, 0) { } }
Neste exemplo, os Circle valores passagens de classe representando raio e altura para o construtor fornecidos por Shape do que Circle é derivado. A concluir exemplo usando Shape e Circle aparece neste tópico como Exemplo 3. Exemplo 1 O exemplo a seguir demonstra uma classe com construtores dois classe, uma sem argumentos e outra com dois argumentos. C# class CoOrds { public int x, y; // Default constructor: public CoOrds() { x = 0; y = 0; } // A constructor with two arguments: public CoOrds(int x, int y) { this.x = x; this.y = y; } // Override the ToString method: public override string ToString() { return (System.String.Format("({0},{1})", x, y)); } } class MainClass { static void Main() { CoOrds p1 = new CoOrds(); CoOrds p2 = new CoOrds(5, 3); // Display the results using the overriden ToString method: System.Console.WriteLine("CoOrds #1 at {0}", p1); System.Console.WriteLine("CoOrds #2 at {0}", p2); } }
Saída CoOrds #1 at (0,0) CoOrds #2 at (5,3)
Exemplo 2 Neste exemplo, a classe Person não tem qualquer construtores, nesse caso, um construtor padrão é automaticamente fornecida e os campos são inicializados para seus valores padrão. C# public class Person { public int age; public string name; } class TestPerson { static void Main() { Person p = new Person(); System.Console.Write("Name: {0}, Age: {1}", p.name, p.age); } }
Saída Name: , Age: 0
Visual C# Consolidado
346
Observe que é 0 o valor padrão de age e o valor padrão de name é null. Para obter mais informações sobre valores padrão, consulte Tabela de valores padrão (referência C#). Exemplo 3 O exemplo a seguir demonstra usando o inicializador de classe base. A Circle classe é derivada da classe Shape geral, e a Cylinder classe é derivada de classe Circle. O construtor em cada classe derivada está usando o inicializador de classe base. C# abstract class Shape { public const double pi = System.Math.PI; protected double x, y; public Shape(double x, double y) { this.x = x; this.y = y; } public abstract double Area(); } class Circle : Shape { public Circle(double radius) : base(radius, 0) { } public override double Area() { return pi * x * x; } } class Cylinder : Circle { public Cylinder(double radius, double height) : base(radius) { y = height; } public override double Area() { return (2 * base.Area()) + (2 * pi * x * y); } } class TestShapes { static void Main() { double radius = 2.5; double height = 3.0; Circle ring = new Circle(radius); Cylinder tube = new Cylinder(radius, height); System.Console.WriteLine("Area of the circle = {0:F2}", ring.Area()); System.Console.WriteLine("Area of the cylinder = {0:F2}", tube.Area()); } }
Saída Area of the circle = 19.63 Area of the cylinder = 86.39
Para obter mais exemplos em chamar os construtores de classe base, consulte (referência C#) virtual, Substituir (referência C#). e base (Referência do C#) COMO: Declarar e usar propriedades de leitura/escrita (Guia de programação C#) Propriedades fornecem a praticidade de membros de dados pública sem os riscos que vêm com Acesso desprotegido, não controlada, e não-verificados aos dados de um objeto. Isso é feito através de assessores: especiais métodos que atribuir e recuperar valores do membro de dados subjacente. O Definir acessador permite que membros de dados a ser atribuído, e o Obter acessador recupera valores Membro de dados. Este exemplo mostra uma Person classe que tenha duas propriedades: Name. (Seqüência) e Age (int) Ambas as propriedades fornecem get e set assessores, são considerados para leitura / gravação propriedades. Exemplo C# class Person { private string m_name = "N/A"; private int m_Age = 0; // Declare a Name property of type string: public string Name { get { return m_name; } set { m_name = value; } } // Declare an Age property of type int: public int Age { get { return m_Age; } set { m_Age = value; } } public override string ToString() { return "Name = " + Name + ", Age = " + Age; } } class TestPerson { static void Main() { // Create a new Person object: Person person = new Person(); // Print out the name and the age associated with the person: System.Console.WriteLine("Person details - {0}", person); // Set some values on the person object: person.Name = "Joe"; person.Age = 99; System.Console.WriteLine("Person details - {0}", person); // Increment the Age property: person.Age += 1; System.Console.WriteLine("Person details - {0}", person); } }
Saída
Visual C# Consolidado
347
Person details - Name = N/A, Age = 0 Person details - Name = Joe, Age = 99 Person details - Name = Joe, Age = 100
Programação robusta No exemplo anterior, e Age propriedades são Pública e incluir um get e um set acessador. o Name Isso permite que qualquer objeto para ler e gravar essas propriedades. Às vezes é desejável, entretanto, para excluir uma das assessores. Por exemplo, omitir o set acessador, faz a propriedade somente leitura: C# public string Name { get { return m_name; } }
Como alternativa, você pode expor um acessador publicamente mas tornar a outros particular ou protegido. Para obter mais informações, consulte Acessibilidade Accessor assimétrica. Depois que as propriedades são declaradas, eles podem ser usados como se fossem campos de classe. Isso permite para uma sintaxe muito natural quando tanto obtendo e definindo o valor de uma propriedade, como nas instruções a seguir: C# person.Name = "Joe"; person.Age = 99;
Observe que, um método propriedade set uma variável Especial value está disponível. Essa variável contenha o valor que o usuário especificado, por exemplo: C# m_name = value;
Observe a sintaxe limpa de incrementando a Age propriedade em um Person objeto: C# person.Age += 1;
Se separado set e get métodos foram usados para modelar propriedades, o código equivalente pode parecer isso: person.SetAge(person.GetAge() + 1);
O ToString método for substituído, neste exemplo: C# public override string ToString() { return "Name = " + Name + ", Age = " + Age; }
Aviso que ToString não explicitamente é usado no programa. Ele é chamado por padrão, as WriteLine chamadas. COMO: Definir propriedades abstratas (Guia de programação C#) O exemplo a seguir mostra como definir abstrato propriedades. Uma declaração de propriedade abstract não fornece uma implementação das assessores Propriedade--ele declara que a classe
Visual C# Consolidado
348
suporta propriedades, mas deixa a implementação do acessador para classes derivadas. O exemplo a seguir demonstra como implementar as propriedades herdadas da classe base abstratas. Este exemplo consiste três arquivos, cada um deles são compilados individualmente e seu conjunto resultante é referido pela compilação seguinte: •
abstractshape.cs: a Shape classe que contém uma propriedade abstrata Area.
•
Shapes.cs: Os subclasses da classe Shape.
•
shapetest.cs:. - um programa de Teste para exibir as áreas de alguns Shape derivado objetos
Para compilar exemplo, use o seguinte comando: csc abstractshape.cs shapes.cs shapetest.cs
Isso criará a shapetest.exe arquivo executável. Exemplo Este arquivo declara a Shape classe que contém a Area propriedade do tipo double. C# // compile with: csc /target:library abstractshape.cs public abstract class Shape { private string m_id; public Shape(string s) { // calling the set accessor of the Id property. Id = s; } public string Id { get { return m_id; } set { m_id = value; } } // Area is a read-only property - only a get accessor is needed: public abstract double Area { get; } public override string ToString() { return Id + " Area = " + string.Format("{0:F2}", Area); } } •
Modificadores sobre a propriedade são colocados na declaração Propriedade próprio. Por exemplo: public abstract double Area
•
Quando declarar uma propriedade abstrata (tais como Area, neste exemplo), você simplesmente indicar que assessores Propriedade estão disponíveis, mas não fazer implementá-las. Neste exemplo, apenas um Obter acessador está disponível, portanto a propriedade é somente leitura.
O código a seguir mostra as três subclasses da Shape e como elas substituirão a Area propriedade para fornecer seus próprios implementação. C# // compile with: csc /target:library /reference:abstractshape.dll shapes.cs public class Square : Shape { private int m_side; public Square(int side, string id) : base(id) { m_side = side; } public override double Area { get { // Given the side, return the area of a square: return m_side * m_side; } } } public class Circle : Shape { private int m_radius; public Circle(int radius, string id) : base(id) { m_radius = radius; } public override double Area { get { // Given the radius, return the area of a circle: return m_radius * m_radius * System.Math.PI; } } } public class Rectangle : Shape { private int m_width; private int m_height; public Rectangle(int width, int height, string id) : base(id) { m_width = width; m_height = height; } public override double Area { get { // Given the width and height, return the area of a rectangle: return m_width * m_height; }}}
Visual C# Consolidado
349
O código a seguir mostra um programa de teste que cria um número de Shape-derivado objetos e imprime suas áreas. C# // compile with: csc /reference:abstractshape.dll;shapes.dll shapetest.cs class TestClass { static void Main() { Shape[] shapes = { new Square(5, "Square #1"), new Circle(3, "Circle #1"), new Rectangle( 4, 5, "Rectangle #1") }; System.Console.WriteLine("Shapes Collection"); foreach (Shape s in shapes) { System.Console.WriteLine(s); } } }
Saída Shapes Collection Square #1 Area = 25.00 Circle #1 Area = 28.27 Rectangle #1 Area = 20.00
COMO: Criar um controle que responde a eventos (Guia de programação C#) A Classe, ListWithChangedEvent, que mostra o exemplo simples a seguir o conteúdo da lista a alteração é semelhante para a classe padrão ArrayList mas também chama. sempre que um Changed Evento Tal uma classe de propósito geral pode ser usado de várias maneiras em um programa grande. Por exemplo, um processador de texto pode manter uma lista dos documentos abertos. Sempre que esta alterações da lista, muitos objetos diferentes no Processador de Texto talvez tenha que ser notificado para que a interface do usuário pode ser atualizada. Usando eventos, o código que mantém a lista de documentos não precisa saber quem precisa ser notificado — após a lista de documentos é alterada, o evento é chamado automaticamente e cada objeto que precisa para ser notificado corretamente é notificado. Usando eventos, a modularidade do programa é aumentada. Quando criar um componente geral que pode ser usado como uma classe base para outros componentes, você deve conta para o fato de que eventos, diferentemente de campos, só podem ser chamados de dentro da classe que declarado-los. Classes derivadas diretamente não é possível chamar eventos declarados na classe base. Embora esse seja o que for desejado, às vezes geralmente é apropriado para dar a classe derivada liberdade para chamar o evento. Isso geralmente é feito criando um método protegido chamado para o evento. Ao chamar esse método chamado, classes derivadas podem chamar o evento. Para obter ainda mais flexibilidade, o método chamado geralmente é declarado como virtual, que permite a classe derivada para substituí-lo. Isso permite que a classe derivada para interceptar os eventos que a classe base é chamar, possivelmente fazendo seu próprio processamento de-los. No exemplo a seguir, isso foi feito com o OnChanged método. Uma classe derivada chamar ou substituir esse método se necessário. Uma outra diferença entre eventos e campos é que um evento pode ser colocado em uma interface enquanto não é um campo. Ao implementar a interface, a classe implementação deve fornecer um evento correspondente na classe que implementa a interface. Exemplo C# namespace TestCollections { // A delegate type for hooking up change notifications. public delegate void ChangedEventHandler(object sender, System.EventArgs e); // A class that works just like ArrayList, but sends event // notifications whenever the list changes. public class ListWithChangedEvent : System.Collections.ArrayList { // An event that clients can use to be notified whenever the // elements of the list change. public event ChangedEventHandler Changed; // Invoke the Changed event; called whenever list changes protected virtual void OnChanged(System.EventArgs e) { if (Changed != null) { Changed(this, e); } }
Visual C# Consolidado
350
// Override some of the methods that can change the list; // invoke event after each public override int Add(object value) { int i = base.Add(value); OnChanged(System.EventArgs.Empty); return i; } public override void Clear() { base.Clear(); OnChanged(System.EventArgs.Empty); } public override object this[int index] { set { base[index] = value; OnChanged(System.EventArgs.Empty); } } } } namespace TestEvents { using TestCollections; class EventListener { private ListWithChangedEvent m_list; public EventListener(ListWithChangedEvent list) { m_list = list; // Add "ListChanged" to the Changed event on m_list: m_list.Changed += new ChangedEventHandler(ListChanged); } // This will be called whenever the list changes. private void ListChanged(object sender, System.EventArgs e) { System.Console.WriteLine("This is called when the event fires."); } public void Detach() { // Detach the event and delete the list m_list.Changed -= new ChangedEventHandler(ListChanged); m_list = null; } } class Test { // Test the ListWithChangedEvent class. static void Main() { // Create a new list. ListWithChangedEvent list = new ListWithChangedEvent(); // Create a class that listens to the list's change event. EventListener listener = new EventListener(list); // Add and remove items from the list. list.Add("item 1"); list.Clear(); listener.Detach(); } }}
Saída This is called when the event fires. This is called when the event fires.
Programação robusta •
Declarar um evento Para declarar um evento dentro uma classe, primeiro um Delegar tipo para o evento deve ser declarado, se nenhum já está declarado. C# public delegate void ChangedEventHandler(object sender, System.EventArgs e);
O tipo delegate define o conjunto de argumentos que são passados para o método que manipula o evento. Vários eventos podem compartilhar o mesmo tipo delegate, portanto, essa etapa só é necessária se nenhum tipo delegate adequado já tiver sido declarado. Em seguida, o evento próprio está declarado. C# public event ChangedEventHandler Changed;
Um evento é declarado como um campo de um tipo delegate, exceto que precede a declaração de evento, seguindo os modificadores palavra-chave Evento. Eventos geralmente são declarados Pública, mas qualquer modificador de acessibilidade é permitido. •
Chamar um evento Depois que uma classe tenha declarado um evento, ele pode tratar desse evento exatamente como um campo do tipo delegate indicado. O campo ou será nulo, se nenhum cliente tiver conectado um representante para o evento, ou então se refere a um representante que deve ser chamado quando o evento é chamado. Assim, chamar um evento geralmente isso, primeiro verificando nulo e depois chamar o evento. C# if (Changed != null) { Changed(this, e); }
Chamar um evento só pode ser feito de dentro da classe que declarado o evento. •
Conectando backup a um evento
Visual C# Consolidado
351
De fora a classe que declarado-lo, um evento parece um campo, mas acesso a esse campo é bastante restrito. Somente as coisas que podem ser causadas são Redigir novo representante para aquele campo, e removendo um representante de um campo (possivelmente composto). Isso é feito com e -= operadores. o += Para começar a receber chamadas de eventos, código de cliente primeiro cria um representante do tipo de evento que se refere ao método que deve ser chamado a partir do evento. Depois ele composes esse representante para qualquer outros representantes que o evento pode estar conectado ao uso +=. C# m_list.Changed += new ChangedEventHandler(ListChanged);
Quando o código do cliente é feito recebimento invocações de eventos, ele remove seu representante a partir do evento usando operador -=. C# m_list.Changed -= new ChangedEventHandler(ListChanged);
COMO: Criar eventos que estejam de acordo com as diretrizes do .NET Framework (Guia de programação C#) Permite a linguagem C# para usar qualquer Delegar Tipo, mas o .NET Framework tem mais estrita diretrizes para representantes e eventos. um Evento Caso você pretenda para o componente a ser usado com o .NET Framework, você provavelmente será deseja siga estas diretrizes. As diretrizes .NET Framework indicar que o tipo delegate usado para um evento deve tomar dois parâmetros: um Objeto de origem parâmetro que indica a fonte de evento, e um parâmetro eventos específicos que encapsula qualquer informação adicional sobre o evento. O parâmetro eventos específicos deve derivar da classe EventArgs. Para eventos que não usam qualquer informação adicional, o .NET Framework fornece a EventHandler classe. O exemplo a seguir é como o código em COMO: Criar um controle que responde a eventos (Guia de programação C#), exceto que esta versão segue as diretrizes .NET Framework. Exemplo C# namespace TestCollections { // A class that works just like ArrayList, but sends event // notifications whenever the list changes: public class ListWithChangedEvent : System.Collections.ArrayList { // An event that clients can use to be notified whenever the // elements of the list change: public event System.EventHandler Changed; // Invoke the Changed event; called whenever list changes: protected virtual void OnChanged(System.EventArgs e) { if (Changed != null) { Changed(this, e); } } // Override some of the methods that can change the list; // invoke event after each: public override int Add(object value) { int i = base.Add(value); OnChanged(System.EventArgs.Empty); return i; } public override void Clear() { base.Clear(); OnChanged(System.EventArgs.Empty); } public override object this[int index] { set { base[index] = value; OnChanged(System.EventArgs.Empty); } } } } namespace TestEvents { using TestCollections; class EventListener { private ListWithChangedEvent m_list; public EventListener(ListWithChangedEvent list) { m_list = list; // Add "ListChanged" to the Changed event on m_list: m_list.Changed += new System.EventHandler(ListChanged); } // This will be called whenever the list changes: private void ListChanged(object sender, System.EventArgs e) { System.Console.WriteLine("This is called when the event fires."); } public void Detach() { // Detach the event and delete the list: m_list.Changed -= new System.EventHandler(ListChanged); m_list = null; } } class Test { // Test the
Visual C# Consolidado
352
ListWithChangedEvent class: static void Main() { // Create a new list: ListWithChangedEvent list = new ListWithChangedEvent(); // Create a class that listens to the list's change event: EventListener listener = new EventListener(list); // Add and remove items from the list: list.Add("item 1"); list.Clear(); listener.Detach(); } } }
Saída This is called when the event fires. This is called when the event fires.
COMO: Declarar um evento em uma interface e implementá-lo em uma classe (Guia de programação C#) Este exemplo mostra que é possível para declarar um Evento. No e implementá-lo em um Interface um Classe Exemplo C# public delegate void TestDelegate(); // delegate declaration public interface ITestInterface { event TestDelegate TestEvent; void FireAway(); } public class TestClass : ITestInterface { public event TestDelegate TestEvent; public void FireAway() { if (TestEvent != null) { TestEvent(); } } } public class MainClass { static private void F() { System.Console.WriteLine("This is called when the event fires."); } static void Main() { ITestInterface i = new TestClass(); i.TestEvent += new TestDelegate(F); i.FireAway(); } }
COMO: Usar um dicionário para armazenar instâncias de eventos (Guia de programação C#) Um uso para accessor-declarations é para expor um grande número de eventos sem alocando um campo para cada evento, mas em vez disso, usar um dicionário para armazenar as instâncias de eventos. Só é útil se você tiver um número muito grande de eventos, mas você espera que a maioria dos eventos não será implementada. Exemplo C# public delegate void Delegate1(int i); public delegate void Delegate2(string s); public class PropertyEventsSample { private System.Collections.Generic.Dictionary eventTable; public PropertyEventsSample() { eventTable = new System.Collections.Generic.Dictionary(); eventTable.Add("Event1", null); eventTable.Add("Event2", null); } public event Delegate1 Event1 { add { eventTable["Event1"] = (Delegate1)eventTable["Event1"] + value; } remove { eventTable["Event1"] = (Delegate1)eventTable["Event1"] - value; } } public event Delegate2 Event2 { add { eventTable["Event2"] = (Delegate2)eventTable["Event2"] + value; } remove { eventTable["Event2"] = (Delegate2)eventTable["Event2"] - value; } } internal void FireEvent1(int i) { Delegate1 D; if (null != (D = (Delegate1)eventTable["Event1"])) { D(i); } } internal void FireEvent2(string s) { Delegate2 D; if (null != (D = (Delegate2)eventTable["Event2"])) { D(s); } } } public class TestClass { public static void Delegate1Method(int i) { System.Console.WriteLine(i); } public static void Delegate2Method(string s) { System.Console.WriteLine(s); } static void Main() { PropertyEventsSample p = new PropertyEventsSample(); p.Event1 += new Delegate1(TestClass.Delegate1Method); p.Event1 += new Delegate1(TestClass.Delegate1Method); p.Event1 -= new Delegate1(TestClass.Delegate1Method); p.FireEvent1(2); p.Event2 += new Delegate2(TestClass.Delegate2Method); p.Event2 += new
Visual C# Consolidado
353
Delegate2(TestClass.Delegate2Method); p.Event2 -= new Delegate2(TestClass.Delegate2Method); p.FireEvent2("TestString"); } }
Saída 2 TestString
COMO: Implementar duas interfaces que possuam um evento com o mesmo nome (Guia de programação C#) Outro uso para Evento Propriedades aborda a situação onde você estiver implementando duas interfaces, cada um com um evento com o mesmo nome. Nesse caso, você deve usar uma propriedade de evento explicitamente de implementação. No entanto, ao explicitamente implementar eventos na interface, você precisará fornecer adicionar e remover métodos. Exemplo C# public delegate void Delegate1(); public delegate int Delegate2(string s); public interface I1 { event Delegate1 TestEvent; } public interface I2 { event Delegate2 TestEvent; } public class ExplicitEventsSample : I1, I2 { public event Delegate1 TestEvent; // normal implementation of I1.TestEvent. private Delegate2 TestEvent2Storage; // underlying storage for I2.TestEvent. event Delegate2 I2.TestEvent // explicit implementation of I2.TestEvent. { add { TestEvent2Storage += value; } remove { TestEvent2Storage -= value; } } private void FireEvents() { if (TestEvent != null) { TestEvent(); } if (TestEvent2Storage != null) { TestEvent2Storage("hello"); } } }
COMO: Criar manipuladores de evento no Visual C# Code Editor (Guia de programação C#) O Editor de Código Visual C# oferece uma maneira fácil de criar manipuladores de eventos para o Windows Forms enquanto trabalha no modo Design. A alternativa é exibir o código fonte no modo de exibição Source e adicionar o manipulador de eventos no código. Observação 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 Studio configurações. Para criar um manipulador de eventos usando o Editor de Código Visual C# 1.
Se clique com o botão direito do mouse no formulário ou controle para o qual você deseja criar um manipulador de eventos, e selecione Properties. não estiver visível, no modo Design, o Properties Window
2.
Na parte superior da Properties Window, clique no botão Events.
3.
Clique duas vezes no evento que você deseja criar, por exemplo o evento Load. Visual C# Cria um método do manipulador de evento vazio e adiciona-o para o seu código. Como alternativa você pode adicionar o código em mãos no modo de exibição de código. Por exemplo as seguintes linhas de código declarar um manipulador de eventos de carga para uma Form classe chamada Form1.
Visual C# Consolidado
354
C# private void Form1_Load(object sender, System.EventArgs e) { // Add your form load event handling code here. }
COMO: Implementar explicitamente membros de uma interface (Guia de programação C#) Este exemplo declara um Interface, IDimensions, e uma classe, Box., explicitamente que implementa os membros getLength de interface e getWidth Os membros são acessados através a instância dimensions interface. Exemplo C# interface IDimensions { float getLength(); float getWidth(); } class Box : IDimensions { float lengthInches; float widthInches; Box(float length, float width) { lengthInches = length; widthInches = width; } // Explicit interface member implementation: float IDimensions.getLength() { return lengthInches; } // Explicit interface member implementation: float IDimensions.getWidth() { return widthInches; } static void Main() { // Declare a class instance box1: Box box1 = new Box(30.0f, 20.0f); // Declare an interface instance dimensions: IDimensions dimensions = (IDimensions)box1; // The following commented lines would produce compilation // errors because they try to access an explicitly implemented // interface member from a class instance: //System.Console.WriteLine("Length: {0}", box1.getlength()); //System.Console.WriteLine("Width: {0}", box1.getwidth()); // Print out the dimensions of the box by calling the methods // from an instance of the interface: System.Console.WriteLine("Length: {0}", dimensions.getLength()); System.Console.WriteLine("Width: {0}", dimensions.getWidth()); } }
Saída Length: 30 Width: 20
Programação robusta •
Observe que as seguintes linhas no método Main, e são comentadas porque eles produziria erros de compilação. Um membro de interface que é implementado explicitamente não pode ser acessado de uma Classe instância: C# //System.Console.WriteLine("Length: {0}", box1.getlength()); //System.Console.WriteLine("Width: {0}", box1.getwidth());
•
Observe também que as seguintes linhas no método Main, e com êxito imprima as dimensões da caixa porque os métodos estão sendo chamados de uma instância da interface: C# System.Console.WriteLine("Length: {0}", dimensions.getLength()); System.Console.WriteLine("Width: {0}", dimensions.getWidth());
COMO: Implementar explicitamente membros de uma interface com herança (Guia de programação C#) Implementação explícita Interface também permite que o programador para implementar duas interfaces que têm os mesmos nomes membro e concedidos aos membros interface uma implementação separada. Este exemplo exibe as dimensões de uma caixa na métrica e unidades em inglês. As Box Classe interfaces IEnglishDimensions implementa dois e IMetricDimensions, que
Visual C# Consolidado
355
representam os sistemas de medida diferente. As duas interfaces ter nomes idênticos membro, Length e Width. Exemplo C# // Declare the English units interface: interface IEnglishDimensions { float Length(); float Width(); } // Declare the metric units interface: interface IMetricDimensions { float Length(); float Width(); } // Declare the Box class that implements the two interfaces: // IEnglishDimensions and IMetricDimensions: class Box : IEnglishDimensions, IMetricDimensions { float lengthInches; float widthInches; public Box(float length, float width) { lengthInches = length; widthInches = width; } // Explicitly implement the members of IEnglishDimensions: float IEnglishDimensions.Length() { return lengthInches; } float IEnglishDimensions.Width() { return widthInches; } // Explicitly implement the members of IMetricDimensions: float IMetricDimensions.Length() { return lengthInches * 2.54f; } float IMetricDimensions.Width() { return widthInches * 2.54f; } static void Main() { // Declare a class instance box1: Box box1 = new Box(30.0f, 20.0f); // Declare an instance of the English units interface: IEnglishDimensions eDimensions = (IEnglishDimensions)box1; // Declare an instance of the metric units interface: IMetricDimensions mDimensions = (IMetricDimensions)box1; // Print dimensions in English units: System.Console.WriteLine("Length(in): {0}", eDimensions.Length()); System.Console.WriteLine("Width (in): {0}", eDimensions.Width()); // Print dimensions in metric units: System.Console.WriteLine("Length(cm): {0}", mDimensions.Length()); System.Console.WriteLine("Width (cm): {0}", mDimensions.Width()); } }
Programação robusta Se você desejar tornar as medidas padrão em inglês unidades, implementar os métodos Length e Width Normalmente, e explicitamente implementar os métodos Comprimento e Largura da interface IMetricDimensions: C# // Normal implementation: public float Length() { return lengthInches; } public float Width() { return widthInches; } // Explicit implementation: float IMetricDimensions.Length() { return lengthInches * 2.54f; } float IMetricDimensions.Width() { return widthInches * 2.54f; }
Nesse caso, você pode acessar as unidades inglês da instância de classe e acessar as unidades métrica de interface a instância: C# public static void Test() { Box box1 = new Box(30.0f, 20.0f); IMetricDimensions mDimensions = (IMetricDimensions)box1; System.Console.WriteLine("Length(in): {0}", box1.Length()); System.Console.WriteLine("Width (in): {0}", box1.Width()); System.Console.WriteLine("Length(cm): {0}", mDimensions.Length()); System.Console.WriteLine("Width (cm): {0}", mDimensions.Width()); }
Visual C# Consolidado
356
Classes genéricas no .NET Framework Generics permitem que você personalizar um método, classe, estrutura ou interface para o tipo de dados precisa Ele age sobre. Por exemplo, em vez de usar a Hashtable classe, que permite chaves e valores sejam de qualquer tipo, você pode usar a Dictionary classe genérico e especifique o tipo permitido para a chave e o tipo permitido para o valor. Entre os benefícios da generics estão código maior segurança reutilização e tipo. Do System.Collections.Generic um número de classes a coleção genérica é fornecido no .NET Framework, no e System.Collections.ObjectModel espaços de nome. Genéricos interfaces para implementar comparações classificar e igualdade são fornecidos no espaço para nome System, juntamente com tipos de representante genérico para manipuladores de eventos, conversões e predicados da pesquisa. Suporte para generics foi adicionada ao System.Reflection para examinar tipos genéricos e métodos genéricos para System.Reflection.Emit para emissor dinâmico conjuntos que contêm tipos genéricos e métodos, e para System.CodeDOM para gerar origem Graphs que incluem generics. Visual Basic, C#, e Visual C++ fornecem suporte completo para definir e usar tipos genéricos. O Common Language Runtime fornece nova operação 8087 e prefixos para oferecer suporte aos tipos genéricos no Microsoft (MSIL) linguagem intermediária.
Visão geral sobre Generics no .NET Framework Este tópico fornece uma visão geral sobre os seguintes recursos de generics no .NET Framework e o Common Language Runtime: • • • • •
Um resumo de tipos genéricos e métodos e a terminologia para falar sobre eles. Do System.Collections.Generic a coleção genérica classes no e System.Collections.ObjectModel espaços de nome. Outros tipos genéricos. Genéricos representantes de conversões, predicados de pesquisa, e ações devem ser feitos em elementos de uma matriz ou coleção. Genéricos interfaces para fornecer funcionalidade Common de famílias de tipos genéricos.
O que são Generics, e como eles são usados e definido? Generics são classes, estruturas, interfaces, e métodos que possuem espaços reservados (parâmetros tipo) para uma ou mais dos tipos que armazenar ou usar. Uma classe a coleção genérica pode utilizar um parâmetro tipo como espaço reservado para o tipo de objetos que ele armazena; os parâmetros tipo aparecem como os tipos de seus campos, e os tipos de parâmetro de seus métodos. Um método genérico pode usar seu parâmetro tipo como o tipo de seu valor de retorno, ou como o tipo de um dos seus parâmetros formais. O código a seguir ilustra uma definição de classe genérico simples. C# public class Generic { public T Field; }
Quando você cria uma instância de uma classe genérico, você especificar os tipos reais para substituir para os parâmetros tipo. Isso estabelece uma nova classe genérico, conhecido como uma classe genérico construído, com seus tipos substituídos em todos os lugares que aparecem
Visual C# Consolidado
357
os parâmetros tipo escolhidos. O resultado é uma classe Safe tipo-adequado para sua escolha de tipos, como o código a seguir ilustra. C# Generic g = new Generic(); g.Field = "A string";
Os seguintes termos são usados para falar sobre generics no .NET Framework: •
A Definição de tipo genérico é uma classe, estrutura, ou declaração interface que funciona como um modelo, com espaços reservados para os tipos-pode conter ou usar. Por exemplo, a Dictionary classe pode conter dois tipos: chaves e valores. Porque ele é apenas um modelo, você não pode criar instâncias de uma classe, estrutura ou interface que é uma definição de tipo genérico.
•
Parâmetros tipo genérico ou Parâmetros tipo, são espaços reservados em uma definição tipo ou método genérico. O Dictionary tipo genérico tem dois parâmetros Tipo, TKey e TValue, que representa os tipos de suas chaves e valores.
•
A Construído tipo genérico, ou Tipo construído, é o resultado da especificando tipos para os parâmetros tipo genérico de uma definição de tipo genérico.
•
A Argumento tipo genérico é qualquer tipo que é substituído para um parâmetro tipo genérico. O termo geral " tipo genérico " inclui os construído tipos e definições tipo genérico.
• •
limites são Restrições colocados em parâmetros tipo genérico. Por exemplo, você pode limitar um parâmetro tipo para tipos que implementam a IComparer interface genérica, para garantir que instâncias do tipo podem ser pedidas. Você também pode restringir parâmetros tipo para tipos que tenham uma classe base específico, que tem um construtor padrão, ou que são tipos de referência ou tipos de valores. Usuários do tipo genérico não podem substituir argumentos tipo que não faça satisfazer as restrições.
•
A definição Método genérico é um método com duas listas de parâmetro: uma lista de parâmetros tipo genérico, e uma lista de parâmetros formais. Parâmetros tipo podem aparecer como o tipo de retorno ou como os tipos de parâmetros formais, como no código a seguir. C# T Generic(T arg) { T temp = arg; ...}
Métodos genéricos podem aparecer em tipos genéricos ou nongeneric. É importante para Observe que um método é não genérico apenas porque ele pertence a um tipo genérico, ou mesmo porque tem parâmetros formais cujos tipos são os parâmetros do tipo delimitador genéricos. Um método é somente se tiver sua própria lista de parâmetros tipo genérico. No código a seguir, único método G é genérico. C# class A { T G(T arg) {...} } class Generic { T M(T arg) {...} }
Visual C++, C#, e Visual Basic todos os fornecem suporte completo para definir e consumindo generics. Para obter mais informações, consulte Tipos genérics no Visual Basic, Introdução ao Generics (guia de programação C#). e Overview of Generics in C++ Tipos e Generics aninhadas Um tipo aninhado em um tipo genérico pode depender os parâmetros os tipo de delimitador o tipo genérico, e esses tipos aninhados são considerados genéricos pelo tempo de execução de idioma comum, mesmo que eles não tenham parâmetros tipo genérico de seus próprios. Quando você
Visual C# Consolidado
358
cria uma instância de um tipo aninhado, é necessário para especificar argumentos Tipo para todos os delimitador tipos genéricos. Genéricas coleções no .NET Framework Do System.Collections.Generic um número de classes a coleção genérica é fornecido na biblioteca de classe do .NET Framework, no e System.Collections.ObjectModel espaços de nome. Para obter mais informações sobre essas classes, consulte Comumente usados tipos da coleção. System.Collections.Generic Muitos dos tipos a coleção genérica são diretas analogs dos tipos nongeneric. é Dictionary uma versão genérica do Hashtable; ele utiliza a estrutura KeyValuePair genérica para enumeração, em vez de DictionaryEntry. é List uma versão do ArrayList genérico. Não há genérico Queue e Stack Classes correspondente às versões nongeneric. Existem versões genérico e nongeneric do SortedList, ambos os quais são híbridas entre um dicionário e uma lista, e que têm características de desempenho semelhante. A SortedDictionary classe genérico é um dicionário que oferece características de desempenho diferente, e que possui nenhum contraparte nongeneric puro. A LinkedList classe genérico é uma lista vinculada verdadeira. Não tem nenhum contraparte nongeneric. System.Collections.ObjectModel A Collection classe genérico oferece uma classe base para derivar seus próprios tipos a coleção genérica. A ReadOnlyCollection classe fornece uma maneira fácil de produzir uma coleção somente leitura de qualquer tipo que implementa a IList interface genérico. A KeyedCollection classe genérica oferece uma maneira para armazenar objetos que contêm suas próprias chaves. Outros tipos genérico A Nullable estrutura genérica, você pode usar tipos valor como se eles pode ser atribuídos null. Isso pode ser útil ao trabalhar com consultas de banco de dados, onde campos que contêm tipos de valor podem ser ausentes. O parâmetro tipo genérico pode ser qualquer tipo de valor. Observação Em C# não é necessário para usar Nullable explicitamente, porque o idioma tem sintaxe para tipos anuláveis. A ArraySegment estrutura genérica oferece uma maneira para delimitar um intervalo de elementos em uma matriz unidimensional, baseada em zero de qualquer tipo. O parâmetro tipo genérico é o tipo de elementos da matriz na. O EventHandler representante genérico elimina a necessidade para declarar um tipo delegate para manipular eventos se o evento segue o padrão tratamento de eventos-usado pelo .NET Framework. Por exemplo, suponha que você tiver criado uma MyEventArgs classe, derivado de
Visual C# Consolidado
359
EventArgs, para manter os dados para o evento. Então você pode declarar o evento da seguinte maneira: C# public event EventHandler MyEvent;
Representantes genéricos para Manipulating matrizes e listas O Action representante genérico representa um método que efetua alguma ação em um elemento do tipo especificado. Você pode criar um método que executa a ação desejada no elemento, criamos uma instância do representante Action para representar esse método, e depois passar a matriz e o representante para o System.Array.ForEach.Action{ método estático genérico O método é chamado para cada elemento da matriz. A List classe genérica também oferece um ForEach método que usa o Action representante. Esse método é não genérico. Observação Isso torna um ponto interessante sobre tipos genéricos e métodos. O System.Array.ForEach.Action{ método deve ser estático (Shared. porque Array) e genérico no Visual Basic não é um tipo genérico; o único motivo você pode especificar um tipo para System.Array.ForEach.Action{ para operar em é que o método possui sua própria lista de Parâmetro tipo Por outro lado, o método nongeneric System.Collections.Generic.List.ForEach(System.Action{ pertence à classe List genérico, para ele simplesmente utiliza o parâmetro Tipo de sua classe. A classe altamente for digitada, portanto, o método pode ser um método de instância. O Predicate representante genérico representa um método que determina se um determinado elemento atende critérios você definir. Poderá usá-lo com os seguintes métodos estáticos genéricos de Array para procurar por um elemento ou um conjunto de elementos: Exists., FindLastFindIndex, FindAllFind, FindLastIndex e TrueForAll Também Predicate funciona com os métodos correspondentes nongeneric da instância da classe List genérico. O Comparison representante genérico permite que você para fornecer uma ordem de classificação de matriz ou lista elementos que não têm uma ordem de classificação nativo, ou para substituir a ordem de classificação nativo. Criar um método que executa a comparação, criar uma instância do representante Comparison para representar o método, e depois passar a matriz e o representante para o System.Array.Sort.Comparison{ método genérico estático. A List classe genérico oferece uma sobrecarga método da instância correspondente, System.Collections.Generic.List.Sort(System.Comparison{. O Converter representante genérico permite que você para definir uma conversão entre dois tipos, e para converter uma matriz de um tipo em uma matriz de outro, ou para converter uma lista de um tipo em uma lista do outro. Criar um método que converte os elementos de lista existente para um novo tipo, criar uma instância delegado para representar o método, e use o System.Array.ConvertAll.Converter{ método estático genérico para produzir uma matriz do novo tipo da matriz original, ou o System.Collections.Generic.List.ConvertAll.Converter{ método da instância genérico para produzir uma lista do novo tipo a partir da lista original.
Visual C# Consolidado
360
O encadeamento representantes Muitos dos métodos que usam esses representantes retornar uma matriz ou lista, que pode ser passada para outro método. Por exemplo, se você desejar selecionar determinados elementos de uma matriz, converter esses elementos para um novo tipo, e salvá-las em uma nova matriz, você pode passar a matriz retornada pelo método FindAll genérico para o ConvertAll método genérico. Se o novo tipo elemento possui uma ordem de classificação natural, você poderá passar a matriz retornada pelo método ConvertAll genérico para o Sort método genérico. Interfaces genérico Interfaces genéricos fornecem contrapartes Safe tipo-a nongeneric interfaces para Ordem e igualdade comparações e para funcionalidade compartilhado por tipos a coleção genérica. Igualdade e classificação Comparisons Do System.IComparable no espaço para nome System, e System.IEquatable genéricos interfaces, como suas contrapartes nongeneric, definir métodos para ordenar comparações e comparações de igualdade, respectivamente. Tipos implementar essas interfaces para fornecer a capacidade de executar tais comparações. No espaço para nome System.Collections.Generic, ou System.IEquatable interface genérica e eles fornecem uma maneira para redefinir os relacionamentos de tipos que fazem. e IEqualityComparer Definir uma comparação ordenação ou igualdade para tipos que não implementam oferta interfaces genérico uma maneira o IComparer o System.IComparable Essas interfaces são usados por métodos e construtores de muitas das classes a coleção genérica. Por exemplo, você pode passar um genérica IComparer para o construtor da classe SortedDictionary para especificar uma ordem de classificação para um tipo que não implementa genérico System.IComparable. Existem overloads do System.Array.Sort método estático genérico e o System.Collections.Generic.List.Sort(System.Collections.Generic.IComparer{ método da instância para classificação matriz e lista usando implementações genéricas IComparer. O Comparer e também fornecem comparações ordem e igualdade padrão por seus respectivas System.Collections.Generic.Comparer.Default e System.Collections.Generic.EqualityComparer.Default Propriedades. e EqualityComparer Classes genéricos fornecem classes básicas para implementações de e IEqualityComparer Interfaces genéricos, o IComparer Funcionalidade coleção A ICollection interface genérica é a interface para a coleção genérica tipos básico. Fornece funcionalidade básica para adicionar, remover, copiar, e enumerar elementos. Herda ICollection da genérico IEnumerable e nongeneric IEnumerable. A IList interface genérica estende a ICollection interface genérica com métodos para recuperação indexado. A IDictionary interface genérica estende a ICollection interface genérica com métodos para recuperação com chave. Tipos do Dicionário genérico na biblioteca de classes base do .NET Framework também implementam a interface nongeneric IDictionary. A IEnumerable interface genérico oferece uma estrutura de enumerador genérico. A IEnumerator interface implementada por enumeradores genéricos genérico herda a interface nongeneric IEnumerator, e MoveNext. e Reset membros, que não faça depender o parâmetro T de tipo, aparecem apenas em uma interface nongeneric Isso significa que qualquer consumidor sobre a interface nongeneric também pode consumir a interface genérica.
Visual C# Consolidado
361
Limitações de Generics A seguir estão algumas limitações de generics no .NET Framework versão 2.0: •
Tipos genéricos podem ser derivados da maioria das classes base, como MarshalByRefObject (e restrições podem ser usadas para exigir que parâmetros tipo genérico derivar de classes base como MarshalByRefObject),. mas nesta versão não há suporte para tipos genéricos vinculados contexto- Um tipo genérico pode ser derivado de ContextBoundObject, mas ao tentar criar uma instância do que digitar causas. um TypeLoadException
•
Enumerações não podem ter parâmetros tipo genérico. Uma enumeração pode ser genérica somente por acaso, por exemplo porque ele estiver aninhado em um tipo genérico definido com Visual Basic, C#, ou C++. Para obter mais informações, consulte Enumerações no CTS (Common Type System).
•
Leve métodos dinâmicos não podem ser genéricos. Para obter mais informações sobre métodos dinâmicos, consulte Reflexo Emit dinâmico cenários método.
•
No Visual Basic, C# e C++ um tipo aninhado entre um tipo genérico não pode ser instanciado a menos que tipos tiverem sido atribuídos aos parâmetros os tipo de todos os tipos de inclusão. Outra maneira de dizer isso é que no reflexo, um tipo aninhado definido usando esses idiomas inclui os parâmetros os tipo de todos os seus tipos delimitador. Isso permite que os parâmetros os Tipo do colocando tipos a ser usado nas definições as membro de um tipo aninhado. Para obter mais informações, consulte " Tipos Nested " no MakeGenericType. Observação Um tipo aninhado que é definido pelo emissor código em um conjunto dinâmico ou usando parâmetros do seu colocando tipos; entretanto, se não tiver depois os parâmetros tipo são não no escopo na classe aninhada. Não é necessário para incluir o tipo a Assembler MSIL (Ilasm.exe)
•
Para obter mais informações, consulte " Tipos Nested " no MakeGenericType.
Vantagens de Generics Permitindo que você para especificar os tipos específicos acionados por uma classe genérico ou método, o recurso generics desloca a sobrecarga de segurança de tipos de você para o compilador. Não é necessário ao gravar código para teste para o tipo de dados correto, porque ele é imposto em tempo de compilação. A necessidade de diretores tipo e a possibilidade de erros em tempo de execução são reduzidas. Generics fornecem segurança tipo sem a sobrecarga de várias implementações. Por exemplo, crie uma lista vinculada de seqüências com a seguinte declaração de variável: C# LinkedList llist = new LinkedList();
Não é necessário para herdar de um tipo base e substituem membros. A lista vinculada está pronta para uso imediato. Consulte System.Collections.Generic e System.Collections.ObjectModel para os tipos a coleção genérica fornecidos pelo .NET Framework. Além de segurança de tipo, tipos a coleção genérica geralmente executar melhor para armazenar e manipular tipos valor porque não há há necessidade de caixa os tipos valor.
Visual C# Consolidado
362
Representantes genéricos Ativar retornos de chamada Segurança tipo-sem a necessidade para criar representante várias classes. Por exemplo, o Predicate representante genérico permite que você a criar um método que implementa seu próprio critérios para um tipo específico e a usar o método com métodos do tipo Array, como Find, FindLast,. e FindAll Representantes genéricos também podem ser usados no código gerado dinamicamente sem exigir a geração de um tipo delegate. Isso aumenta o número de cenários em que você pode usar Lightweight métodos dinâmicos em vez de gerar conjuntos todos. Para obter mais informações, consulte Como Definir e Executar Métodos Dinâmicos e DynamicMethod. Em muitos casos, o Visual Basic, Visual C++ e compiladores C# são capazes de determinação do contexto os tipos usados por uma chamada de método genérico, bastante simplificando a sintaxe para usar métodos genéricos. Por exemplo, o código a seguir mostra os formulários de chamar o BinarySearch método para pesquisar uma matriz de seqüências genérico curto e longo. No formulário curto, os compiladores inferir o parâmetro tipo correto dos tipos de argumentos do método. C# int index = Array.BinarySearch(myArray, "test string"); int index = Array.BinarySearch(myArray, "test string");
A palavra-chave default em código fonte "genérico" (Guia de programação C#) No genéricos classes e métodos, um problema que surge é como atribuir um valor padrão a um tipo parametrizado T quando você não faça sabe o seguinte antecedência: •
Se T será um tipo de referência ou um tipo de valor.
•
Se T for um tipo de valor, se ele será um valor numérico ou uma estrutura.
Fornecido uma variável t de um tipo parametrizado T, a instrução t =. Se T é um tipo de referência e t = trabalho somente será 0 para tipos valor numérico mas não para estruturas nulo só é válido A solução é para usar a default palavra-chave, que retornará nula para tipos de referência e zero para tipos valor numérico. Para estruturas, ele retornará cada membro da estrutura inicializada com zero ou nulo dependendo se eles são tipos valor ou referência. O exemplo a partir da GenericList classe a seguir mostra como usar a default palavra-chave. Para obter mais informações, consulte Visão geral generics. C# public class GenericList { private class Node { //... public Node Next; public T Data; } private Node head; //... public T GetNext() { T temp = default(T); Node current = head; if (current != null) { temp = current.Data; current = current.Next; } return temp; } }
Métodos genérico (Guia de programação C#) Um método genérico é um método que está declarado com parâmetros Tipo, da seguinte maneira: C# static void Swap(ref T lhs, ref T rhs) { T temp; temp = lhs; lhs = rhs; rhs = temp; }
Visual C# Consolidado
363
O exemplo de código a seguir mostra uma maneira de chamar o método, usando Int para o argumento Tipo: C# public static void TestSwap() { int a = 1; int b = 2; Swap(ref a, ref b); System.Console.WriteLine(a + " " + b); }
Você também pode omitir o argumento Tipo e o compilador deduzirá-lo. A chamada para permutar a seguir é equivalente como a chamada anterior: C# Swap(ref a, ref b);
As mesmas regras para a inferência tipo se aplicam a métodos estáticos, bem como métodos da instância. O compilador é capaz de inferir os parâmetros tipo com base em argumentos do método você passar na; ele não pode inferir os parâmetros tipo somente de uma restrição ou retornar valor. Portanto, a inferência tipo não funciona com os métodos que possuem sem parâmetros. Ocorre a inferência tipo em tempo de compilação antes o compilador tenta se resolver nenhuma assinatura método sobrecarregado. Se o compilador aplica lógica a inferência tipo a todos os métodos que compartilham o mesmo nome genéricos. Na etapa de resolução de sobrecarga, o compilador inclui apenas esses métodos genéricos no qual a inferência tipo êxito. Em uma classe genérico, métodos não-Generic podem acessar os parâmetros tipo nível de classe, da seguinte maneira: C# class SampleClass { void Swap(ref T lhs, ref T rhs) { } }
Se você definir um método genérico que leva os mesmos parâmetros tipo como a classe que contém o compilador irá gerar aviso CS0693 porque dentro do escopo método, o argumento fornecido para o T interna ocultará o argumento fornecido para o T. externa Se você exigir a flexibilidade de chamar um método de classe genérico com argumentos Tipo diferente aquelas fornecidas quando a classe foi instanciada, considere fornecer outro identificador para do método Parâmetro tipo, como mostrado GenericList2 no exemplo a seguir. C# class GenericList { // CS0693 void SampleMethod() { } } class GenericList2 { //No warning void SampleMethod() { } }
Utilizar restrições para ativar operações mais especializadas em parâmetros tipo nos métodos. Esta versão do Swap, agora chamado SwapIfGreater, somente pode ser usada com argumentos Tipo que implementam IComparable. C# void SwapIfGreater(ref T lhs, ref T rhs) where T : System.IComparable { T temp; if (lhs.CompareTo(rhs) > 0) { temp = lhs; lhs = rhs; rhs = temp; } }
Métodos genéricos podem ser sobrecarregados em um número de parâmetros tipo. Por exemplo, os seguintes métodos podem todos existir na mesma classe: C#
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, StackEventArgs> 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"); } }
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) {return (.10 * income);} if (income > 7000 && income <= 28400) {return 700.00 + (.15 * (income - 7000));} if (income > 28400 && income <= 68800) {return 3910.00 + (.25 * (income - 28400));} if (income > 68800 && income <= 143500) {return 14010.00 + (.28 * (income - 68800));} if (income > 143500 && income <= 311950) {return 34926.00 + (.33 * (income - 143500));} if (income > 311950) {return 90514.50 + (.35 * (income 311950));} return 0; } [ComRegisterFunctionAttribute] public static void RegisterFunction(System.Type t) { Microsoft.Win32.Registry.ClassesRoot.CreateSubKey ("CLSID\\{"
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(); }
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."); } }
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<4; i++) { Thread.Sleep(2500); ShowQueueContents(queue); }
Finalmente, Main sinaliza a segmentos de trabalho para encerrar, chamar o Set método do evento " do segmento de saída ", e chama o Join método em cada segmento de trabalho para bloquear o segmento primário até que cada segmento do operador responder ao evento e termina. Não é um exemplo final da sincronização do segmento: o ShowQueueContents método. Esse método, como os segmentos consumidor e o Producer, usa lock para obter acesso exclusivo para a fila. Nesse caso, entretanto, acesso exclusivo é particularmente importante, porque ShowQueueContents. enumera em toda a coleção Enumerando sobre uma coleção é uma operação que está especialmente propensa a corrupção de dados por operações assíncronas porque ela envolve atravessando o conteúdo de toda a coleção. O ShowQueueContents método tem a seguinte aparência: C# syncEvents.ExitThreadEvent.Set(); producerThread.Join(); consumerThread.Join();
Finalmente, observe que ShowQueueContents, porque ela é chamada por Main, é executado pelo segmento primário. Isso significa que esse método, quando ele obtém acesso exclusivo à fila item, na verdade está bloqueando os dois segmentos Producer e pelo consumidor de acessar a fila. Bloqueia ShowQueueContents a fila e enumera o conteúdo: C# private static void ShowQueueContents(Queue q) { lock (((ICollection)q).SyncRoot) { foreach (int item in q) { Console.Write("{0} ", item); } } Console.WriteLine(); }
O exemplo completo segue. Exemplo C# using System; using System.Threading; using System.Collections; using System.Collections.Generic; public class SyncEvents { public SyncEvents() { _newItemEvent = new AutoResetEvent(false); _exitThreadEvent = new ManualResetEvent(false); _eventArray = new WaitHandle[2]; _eventArray[0] = _newItemEvent; _eventArray[1] = _exitThreadEvent; } public EventWaitHandle ExitThreadEvent { get { return _exitThreadEvent; } } public EventWaitHandle NewItemEvent { get { return _newItemEvent; } } public WaitHandle[] EventArray { get { return _eventArray; } } private EventWaitHandle _newItemEvent; private EventWaitHandle _exitThreadEvent; private WaitHandle[] _eventArray; } public class Producer { public Producer(Queue q, SyncEvents e) { _queue = q; _syncEvents = e; } // Producer.ThreadRun public void ThreadRun() { int count = 0; Random r = new Random(); while (!_syncEvents.ExitThreadEvent.WaitOne(0, false)) { lock (((ICollection)_queue).SyncRoot) { while (_queue.Count < 20) { _queue.Enqueue(r.Next(0,100)); _syncEvents.NewItemEvent.Set(); count++; } } } Console.WriteLine("Producer thread: produced {0} items", count); } private Queue _queue; private SyncEvents _syncEvents; } public class Consumer { public Consumer(Queue q, SyncEvents e) { _queue = q; _syncEvents = e; } // Consumer.ThreadRun public void ThreadRun() { int count = 0; while (WaitHandle.WaitAny(_syncEvents.EventArray) != 1) { lock (((ICollection)_queue).SyncRoot) { int item =
Visual C# Consolidado
384
_queue.Dequeue(); } count++; } Console.WriteLine("Consumer Thread: consumed {0} items", count); } private Queue _queue; private SyncEvents _syncEvents; } public class ThreadSyncSample { private static void ShowQueueContents(Queue q) { lock (((ICollection)q).SyncRoot) { foreach (int item in q) { Console.Write("{0} ", item); } } Console.WriteLine(); } static void Main() { Queue queue = new Queue(); SyncEvents syncEvents = new SyncEvents(); Console.WriteLine("Configuring worker threads..."); Producer producer = new Producer(queue, syncEvents); Consumer consumer = new Consumer(queue, syncEvents); Thread producerThread = new Thread(producer.ThreadRun); Thread consumerThread = new Thread(consumer.ThreadRun); Console.WriteLine("Launching producer and consumer threads..."); producerThread.Start(); consumerThread.Start(); for (int i=0; i<4; i++) { Thread.Sleep(2500); ShowQueueContents(queue); } Console.WriteLine("Signaling threads to terminate..."); syncEvents.ExitThreadEvent.Set(); producerThread.Join(); consumerThread.Join(); } }
COMO: Usar um pool de threads (Guia de programação C#) A pool de segmentos é uma coleção de segmentos que podem ser usados para executar um número de tarefas em segundo plano. (Consulte Usando Threading Para obter informações detalhadas.) Isso deixa o segmento primário livre para executar outras tarefas de forma assíncrona. Pools segmento geralmente são empregados em aplicativos de servidor. Cada solicitação de entrada é atribuída a um segmento do pool do segmento, para a solicitação pode ser processada de forma assíncrona, sem atrasar o processamento de solicitações subseqüentes amarrando backup o segmento primário ou. Depois que um segmento no pool conclui a tarefa, ele é retornado para uma fila de segmentos de espera, onde ele pode ser reutilizado. Essa reutilização permite que aplicativos para evitar o custo de criar um novo segmento para cada tarefa. Pools segmento normalmente ter um número máximo de segmentos. Se estiver ocupados, todos os segmentos tarefas adicionais são colocadas na fila até que eles podem ser atendidos medida segmentos se tornam disponíveis. Você pode implementar seu próprio pool do segmento, mas ele é mais fácil de usar o pool de segmentos fornecido pelo .NET Framework por meio da ThreadPool classe. O exemplo a seguir usa o pool de segmentos do .NET Framework para calcular o Fibonacci resultado de dez números entre 20 e 40. Cada Fibonacci resultado é representado pela classe Fibonacci, que fornece um método chamado ThreadPoolCallback que executa o cálculo. Um objeto que representa cada valor Fibonacci é criado e é passado para QueueUserWorkItem o ThreadPoolCallback método que atribui um segmento disponível no pool para executar o método. Como cada Fibonacci objeto é dado um valor semi-Random para calcular, e como será cada um dos segmentos dez ser competindo de Tempo processador, não há um meio para ser instruídos com antecedência quanto tempo levará para todos os resultados dez deve ser calculado. É por isso que cada Fibonacci objeto é passado uma instância da classe ManualResetEvent durante a
Visual C# Consolidado
385
construção. Cada objeto sinaliza o objeto de evento fornecido quando seu cálculo estiver concluído, que permite o segmento primário para execução de bloco com WaitAll até que todos os objetos dez Fibonacci ter calculado um resultado. O Main método exibirá cada Fibonacci resultado. Exemplo C# using System; using System.Threading; public class Fibonacci { public Fibonacci(int n, ManualResetEvent doneEvent) { _n = n; _doneEvent = doneEvent; } // Wrapper method for use with thread pool. public void ThreadPoolCallback(Object threadContext) { int threadIndex = (int)threadContext; Console.WriteLine("thread {0} started...", threadIndex); _fibOfN = Calculate(_n); Console.WriteLine("thread {0} result calculated...", threadIndex); _doneEvent.Set(); } // Recursive method that calculates the Nth Fibonacci number. public int Calculate(int n) { if (n <= 1) { return n; } return Calculate(n - 1) + Calculate(n - 2); } public int N { get { return _n; } } private int _n; public int FibOfN { get { return _fibOfN; } } private int _fibOfN; private ManualResetEvent _doneEvent; } public class ThreadPoolExample { static void Main() { const int FibonacciCalculations = 10; // One event is used for each Fibonacci object ManualResetEvent[] doneEvents = new ManualResetEvent[FibonacciCalculations]; Fibonacci[] fibArray = new Fibonacci[FibonacciCalculations]; Random r = new Random(); // Configure and launch threads using ThreadPool: Console.WriteLine("launching {0} tasks...", FibonacciCalculations); for (int i = 0; i < FibonacciCalculations; i++) { doneEvents[i] = new ManualResetEvent(false); Fibonacci f = new Fibonacci(r.Next(20,40), doneEvents[i]); fibArray[i] = f; ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i); } // Wait for all threads in pool to calculation... WaitHandle.WaitAll(doneEvents); Console.WriteLine("All calculations are complete."); // Display the results... for (int i= 0; i
Saída de exemplo launching 10 tasks... result calculated... result calculated... result calculated... result calculated... result calculated... result calculated... result calculated... result calculated... result calculated... result calculated... all calculations complete Fibonacci(22) = 17711 Fibonacci(25) = 75025 Fibonacci(32) = 2178309 Fibonacci(36) = 14930352 Fibonacci(32) = 2178309 Fibonacci(26) = 121393 Fibonacci(35) = 9227465 Fibonacci(23) = 28657 Fibonacci(39) = 63245986 Fibonacci(22) = 17711
COMO: Pesquisar em seqüências de caracteres utilizando expressões regulares (Guia de programação C#) A System.Text.RegularExpressions.Regex classe pode ser usada para procurar seqüências. Essas pesquisas podem variar em complexidade de muito simples a fazer uso total de expressões regulares. A seguir são dois exemplos de seqüência pesquisar usando a Regex classe. Para obter mais informações, consulte Expressões regulares .NET Framework. Exemplo O código a seguir é um aplicativo de console que realiza uma pesquisa simples maiúsculas de minúsculas das seqüências de caracteres em uma matriz. O método System.Text.RegularExpressions.Regex.IsMatch(System.String,System.String,System.Text.Regul arExpressions.RegexOptions) estático executa a pesquisa fornecida seqüência para pesquisar e uma seqüência contendo o padrão de pesquisa. Nesse caso, um argumento terceiro é usado para indicar que caso deve ser ignorado. Para obter mais informações, consulte System.Text.RegularExpressions.RegexOptions.
Visual C# Consolidado
386
C# class TestRegularExpressions { static void Main() { string[] sentences = { "cow over the moon", "Betsy the Cow", "cowering in the corner", "no match here" }; string sPattern = "cow"; foreach (string s in sentences) { System.Console.Write("{0,24}", s); if (System.Text.RegularExpressions.Regex.IsMatch(s, sPattern, System.Text.RegularExpressions.RegexOptions.IgnoreCase)) { System.Console.WriteLine(" (match for '{0}' found)", sPattern); } else { System.Console.WriteLine(); } } } }
Saída cow over the moon (match for 'cow' found) Betsy the Cow (match for 'cow' found) cowering in the corner (match for 'cow' found) no match here
O código a seguir é um aplicativo de console que usa expressões regulares para validar o formato da cada seqüência em uma matriz. A validação requer que cada seqüência assumem a forma de um número de telefone no qual três grupos de dígitos são separados por hífen, os primeiros dois grupos conter três dígitos, e o terceiro grupo contém quatro dígitos. Isso é feito com a expressão ^\\d{3}-\\d{3}-\\d{4}$ regular. Para obter mais informações, consulte Elementos de idioma de expressões regulares. C# class TestRegularExpressionValidation { static void Main() { string[] numbers = { "123-456-7890", "444234-22450", "690-203-6578", "146-893-232", "146-839-2322", "4007-295-1111", "407-295-1111", "407-25555", }; string sPattern = "^\\d{3}-\\d{3}-\\d{4}$"; foreach (string s in numbers) { System.Console.Write("{0,14}", s); if (System.Text.RegularExpressions.Regex.IsMatch(s, sPattern)) { System.Console.WriteLine(" - valid"); } else { System.Console.WriteLine(" - invalid"); } } } }
COMO: Unir várias seqüências de caracteres (Guia de programação C#) Há duas maneiras para ingressar em várias seqüências: usando o + operador que a String classe overloads, e usando a StringBuilder classe. O + operador é fácil de usar e torna para intuitivo código, mas ele funciona em seqüência; uma nova seqüência é criada para cada uso do operador, portanto encadeamento vários operadores juntos é ineficiente. Por exemplo: C# string two = "two"; string str = "one " + two + " three"; System.Console.WriteLine(str);
Embora quatro seqüências aparecem no código, a três seqüências sendo associados e a seqüência de caracteres que contém todos os três, final cinco seqüências são criadas no total porque as primeiras duas seqüências estão associadas primeiro, criar uma seqüência contendo " Um dois ". O terceiro é acrescentado separadamente, formando a seqüência de caracteres armazenada no str final. Como alternativa, a StringBuilder classe pode ser usada para adicionar cada seqüência a um objeto que cria a seqüência final em uma etapa. Essa estratégia é demonstrada no exemplo a seguir. Exemplo
Visual C# Consolidado
387
O código a seguir usa o método acréscimo da classe StringBuilder Para ingressar em três seqüências sem o efeito do + operador Chaining. C# class StringBuilderTest { static void Main() { string two = "two"; System.Text.StringBuilder sb = new System.Text.StringBuilder(); sb.Append("one "); sb.Append(two); sb.Append(" three"); System.Console.WriteLine(sb.ToString()); string str = sb.ToString(); System.Console.WriteLine(str); } }
COMO: Pesquisar em seqüências de caracteres utilizando métodos de String (Guia de programação C#) O Seqüência Tipo, que é um alias para a System.String classe, fornece um número de métodos útil para pesquisar o conteúdo de uma seqüência. O exemplo a seguir utiliza e EndsWith Métodos., StartsWith a IndexOf, LastIndexOf Exemplo C# class StringSearch { static void Main() { string str = "A silly sentence used for silly purposes."; System.Console.WriteLine("'{0}'",str); bool test1 = str.StartsWith("a silly"); System.Console.WriteLine("starts with 'a silly'? {0}", test1); bool test2 = str.StartsWith("a silly", System.StringComparison.OrdinalIgnoreCase); System.Console.WriteLine("starts with 'a silly'? {0} (ignoring case)", test2); bool test3 = str.EndsWith("."); System.Console.WriteLine("ends with '.'? {0}", test3); int first = str.IndexOf("silly"); int last = str.LastIndexOf("silly"); string str2 = str.Substring(first, last - first); System.Console.WriteLine("between two 'silly' words: '{0}'", str2); } }
Saída 'A silly sentence used for silly purposes.' starts with 'a silly'? False starts with 'a silly'? True (ignore case) ends with '.'? True between two 'silly' words: 'silly sentence used for '
COMO: Analisar seqüências usando o método Split (Guia de programação C#) O exemplo de código a seguir demonstra como uma seqüência pode ser analisado usando o System.String.Split método. Esse método funciona, retornando uma matriz de seqüências, onde cada elemento é uma palavra. Como entrada, Split leva uma matriz de caracteres que indicam quais caracteres são a ser usado como delimitadores. Neste exemplo, espaços, vírgulas, pontos, dois-pontos, e guias são usados. Uma matriz contendo esses delimitadores é passado para Split, e cada palavra na frase será exibida separadamente usando a matriz de seqüências de caracteres resultante. Exemplo C# class TestStringSplit { static void Main() { char[] delimiterChars = { ' ', ',', '.', ':', '\t' }; string text = "one\ttwo three:four,five six seven"; System.Console.WriteLine("Original text: '{0}'", text); string[] words = text.Split(delimiterChars); System.Console.WriteLine("{0} words in text:", words.Length); foreach (string s in words) { System.Console.WriteLine(s); } } }
Saída Original text: 'one two three:four,five six seven' 7 words in text: one two three four five six seven
COMO: Criar uma união C/C++ usando atributos (Guia de programação C#)
Visual C# Consolidado
388
Usando atributos Você pode personalizar como estruturas são dispostas na memória. Por exemplo, você pode criar o que é conhecido como uma união em C/C usando e FieldOffset Atributos. o StructLayout(LayoutKind.Explicit) Exemplo Nesse segmento de código, todos os campos de TestUnion início no mesmo local na memória. C# [System.Runtime.InteropServices.StructLayout(LayoutKind.Explicit)] struct TestUnion { [System.Runtime.InteropServices.FieldOffset(0)] public int i; [System.Runtime.InteropServices.FieldOffset(0)] public double d; [System.Runtime.InteropServices.FieldOffset(0)] public char c; [System.Runtime.InteropServices.FieldOffset(0)] public byte b; }
A seguir é outro exemplo onde início campos em diferente explicitamente configurar locais. C# [System.Runtime.InteropServices.StructLayout(LayoutKind.Explicit)] struct TestExplicit { [System.Runtime.InteropServices.FieldOffset(0)] public long lg; [System.Runtime.InteropServices.FieldOffset(0)] public int i1; [System.Runtime.InteropServices.FieldOffset(4)] public int i2; [System.Runtime.InteropServices.FieldOffset(8)] public double d; [System.Runtime.InteropServices.FieldOffset(12)] public char c; [System.Runtime.InteropServices.FieldOffset(14)] public byte b; }
Os dois int campos, i1 e i2, compartilhar os mesmos locais como lg de memória. Esse tipo de controle sobre layout struct é útil quando usando invocação de plataforma. COMO: Criar e usar DLLs em C# (Guia de programação C#) Uma biblioteca de vínculo dinâmica (DLL) está vinculada ao seu programa em tempo de execução. Para demonstrar Criando e usando uma DLL, considere o seguinte cenário: •
MathLibrary.DLL o arquivo de biblioteca que contém os métodos para ser chamado em tempo de execução. Neste exemplo, a DLL contém dois métodos, Add e Multiply.
•
Add.cs o arquivo de origem que contém o método Add(long i, long j). Ela retorna a soma de seus parâmetros. A classe AddClass que contém o método Add é um membro do espaço para nome UtilityMethods.
•
Mult.cs o código fonte que contém o método Multiply(long x, long y). Ele retorna o produto de seus parâmetros. A classe MultiplyClass que contém o método Multiply é também um membro do espaço para nome UtilityMethods.
•
TestCode.cs o arquivo que contém o Main método. Ele usa os métodos no arquivo DLL para
calcular a soma e o produto dos argumentos em tempo de execução. Exemplo C# // File: Add.cs namespace UtilityMethods { public class AddClass { public static long Add(long i, long j) { return (i + j); } } }
Visual C# Consolidado
389
C# // File: Mult.cs namespace UtilityMethods { public class MultiplyClass { public static long Multiply(long x, long y) { return (x * y); } } }
C# // File: TestCode.cs using UtilityMethods; class TestCode { static void Main(string[] args) { System.Console.WriteLine("Calling methods from MathLibrary.DLL:"); if (args.Length != 2) { System.Console.WriteLine("Usage: TestCode "); return; } long num1 = long.Parse(args[0]); long num2 = long.Parse(args[1]); long sum = AddClass.Add(num1, num2); long product = MultiplyClass.Multiply(num1, num2); System.Console.WriteLine("{0} + {1} = {2}", num1, num2, sum); System.Console.WriteLine("{0} * {1} = {2}", num1, num2, product); } }
Este arquivo contém o algoritmo que usa os métodos DLL, Add e Multiply. Começar com analisar os argumentos inseridos da linha de comando, num1 e num2. Ele calcula a soma, usando o Add método na classe AddClass, e o produto usando o Multiply método na classe MultiplyClass. Observe que a using diretiva no início do arquivo permite-lhe usar a classe não qualificado nomes para consultar os métodos DLL ao tempo de compilação, da seguinte maneira: C# MultiplyClass.Multiply(num1, num2);
Caso contrário, você terá para usar os nomes totalmente qualificados, da seguinte maneira: C# UtilityMethods.MultiplyClass.Multiply(num1, num2);
Execução Para executar o programa, digite o nome do arquivo exe, seguido por dois números, da seguinte maneira: TestCode 1234 5678
Compilando o código Para criar o arquivo MathLibrary.DLL, compilar os dois arquivos Add.cs e Mult.cs Usando a linha de comando a seguir: csc /target:library /out:MathLibrary.DLL Add.cs Mult.cs
A /Target:Library opção de compilador informa o compilador para dar saída uma DLL em vez de um arquivo EXE. A / Fora opção de compilador seguida por um nome de arquivo é utilizada para especificar o nome do arquivo DLL Caso contrário, o compilador usa o primeiro arquivo (Add.cs.) como o nome da DLL Para criar o arquivo executável, TestCode.exe, use a seguinte linha de comando: csc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.cs
Visual C# Consolidado
390
A /out opção de compilador informa o compilador para produzir saída de um arquivo EXE e especifica o nome do arquivo de saída). (TestCode.exe Esta opção de compilador é opcional. A /Reference opção de compilador Especifica o arquivo DLL ou arquivos que usa este programa. COMO: Determinar se um arquivo é um módulo (assembly) (Guia de programação C#) Um arquivo é um conjunto se e somente se ele é gerenciada, e contém uma entrada do conjunto nos seus metadados. Para obter mais informações sobre conjuntos e metadados, consulte o tópico Manifesto do Assembly. Como determinar se um arquivo é um conjunto manualmente 1.
Iniciar o Disassembler MSIL (Ildasm.exe).
2.
Carregar o arquivo que deseja testar.
3.
Se ILDASM, arquivo relatórios não que o arquivo é um executável portátil (PE), ele é um conjunto não. Para obter mais informações, consulte o tópico Como Visualizar o Conteúdo de um Assembly.
Como determinar se um arquivo é um conjunto programaticamente 1.
Chame o GetAssemblyName método, passando o caminho de arquivo completo e nome do arquivo que você está testando.
2.
Se uma BadImageFormatException exceção é acionada, o arquivo é um conjunto não.
Exemplo Este exemplo testa uma DLL para verificar se ele é um conjunto. C# class TestAssembly { static void Main() { try { System.Reflection.AssemblyName testAssembly = System.Reflection.AssemblyName.GetAssemblyName(@"C:\WINDOWS\system\avicap.dll"); System.Console.WriteLine("Yes, the file is an Assembly."); } catch (System.IO.FileNotFoundException e) { System.Console.WriteLine("The file cannot be found."); } catch (System.BadImageFormatException e) { System.Console.WriteLine("The file is not an Assembly."); } catch (System.IO.FileLoadException e) { System.Console.WriteLine("The Assembly has already been loaded."); } } }
O GetAssemblyName método carrega o arquivo de teste, e depois libera ele depois que as informações é leitura. Saída The file is not an Assembly.
COMO: Carregar e descarregar módulos (assemblies) (Guia de programação C#) As montagens referenciadas por seu programa automaticamente será carregadas ao tempo de criação, mas também é possível carregar conjuntos específicos para o domínio do aplicativo atual em tempo de execução. Para obter mais informações, consulte Domínios de aplicativo. Não há um meio para descarregar um conjunto individual sem descarregar todos os domínios de aplicativos que contêm ele. Mesmo se o conjunto sai do escopo, o arquivo de montagem real permanecerá carregado até que todos os domínios de aplicativos que contêm ele sejam descarregados.
Visual C# Consolidado
391
Se você desejar descarregar alguns conjuntos mas não outros, considere criar um novo domínio do aplicativo executar o código dentro desse domínio, e então descarregar desse domínio do aplicativo. Para obter mais informações, consulte Como executar código em outro domínio de aplicativo:. Para carregar um conjunto em um domínio de aplicativo •
Use uma das várias a carregar métodos contidos nas classes AppDomain e System.Reflection. Para obter mais informações, consulte Carregar conjuntos em um domínio de aplicativo.
Para descarregar um domínio de aplicativo •
Não há um meio para descarregar um conjunto individual sem descarregar todos os domínios de aplicativos que contêm ele. Use o Unload método do AppDomain para descarregar os domínios de aplicativo. Para obter mais informações, consulte Descarregar um domínio de aplicativo.
COMO: Compartilhar um módulo (assembly) com outros aplicativos (Guia de programação C#) Conjuntos podem ser privado nem compartilhada: Por padrão, simples maioria dos programas C# consistir de um conjunto particular porque eles não se destinam a ser usado por outros aplicativos. Para compartilhar um conjunto com outros aplicativos, ele deve ser colocado no (GAC Cache global de assembly ). Compartilhar um conjunto 1.
Criar seu conjunto. Para obter mais informações, consulte Criando conjuntos.
2.
Atribuir um nome de alta segurança a seu conjunto. Para obter mais informações, consulte COMO: Assinar uma Assembly com Nome Forte.
3.
Atribuir informações de versão a seu conjunto. Para obter mais informações, consulte Versionamento de assembly.
4.
Incluir seu conjunto para o cache assembly global. Para obter mais informações, consulte Como Instalar um Assembly na Cache Global de Assemblies.
5.
Acessar os tipos contidos no conjunto dos outros aplicativos. Para obter mais informações, consulte Como Referenciar um Assembly de Nome Forte.
Executar código em outro domínio de aplicação (Guia de programação C#) Depois que um conjunto tenha sido carregado em um domínio de aplicativo, ele contém o código pode ser executado. A maneira mais simples para fazer isso é para usar AssemblyLoad qual irá carregar o conjunto para o domínio de aplicativos atual, e começar a execução do código em ponto de entrada padrão do conjunto. Se você desejar carregar o conjunto em outro domínio de aplicativo, use ExecuteAssembly ou ExecuteAssemblyByName. ou uma da outra o sobrecarregado versões um desses métodos Se você deseja executar o outro conjunto começando no ponto de entrada padrão, além de definir um novo tipo no conjunto remoto, derivar de MarshalByRefObject. Usar CreateInstance para criar uma instância do tipo do seu aplicativo.
Visual C# Consolidado
392
Considere arquivo a seguir, que cria um conjunto que consiste em um espaço para nome único e duas classes. Suponha que este conjunto de módulos (assembly) tenha sido criado, e é armazenada no disco C com o nome HelloWorldRemote.exe. C# // This namespace contains code to be called. namespace HelloWorldRemote { public class RemoteObject : System.MarshalByRefObject { public RemoteObject() { System.Console.WriteLine("Hello, World! (RemoteObject Constructor)"); } } class Program { static void Main() { System.Console.WriteLine("Hello, World! (Main method)"); } } }
Para acessar o código de outro aplicativo, você pode tanto carregar o conjunto para o domínio de aplicativo atual ou criar um novo domínio de aplicativo e carregar o conjunto para ela Se você carregar o conjunto no domínio de aplicativo atual com Assembly.LoadFrom, você pode usar Assembly.CreateInstance para criar uma instância da classe RemoteObject, que faz o Construtor de objeto a ser executado C# static void Main() { // Load the assembly into the current appdomain: System.Reflection.Assembly newAssembly = System.Reflection.Assembly.LoadFrom(@"c:\HelloWorldRemote.exe"); // Instantiate RemoteObject: newAssembly.CreateInstance("HelloWorldRemote.RemoteObject"); }
Ao carregar o conjunto em um domínio de aplicativos separados, usar AppDomain.ExecuteAssembly para acessar o ponto de entrada padrão ou AppDomain.CreateInstance Para criar uma instância da classe RemoteObject. Criar a instância faz o construtor para ser executado. C# static void Main() { System.AppDomain NewAppDomain = System.AppDomain.CreateDomain("NewApplicationDomain"); // Load the assembly and call the default entry point: NewAppDomain.ExecuteAssembly(@"c:\HelloWorldRemote.exe"); // Create an instance of RemoteObject: NewAppDomain.CreateInstanceFrom(@"c:\HelloWorldRemote.exe", "HelloWorldRemote.RemoteObject"); }
Se você não faça desejar carregar o conjunto programaticamente, use Add Reference de para especificar o conjunto HelloWorldRemote.exe. o Solution Explorer Em seguida, adicionar uma using HelloWorldRemote; diretiva para o Usando Bloco de seu aplicativo, e usar o RemoteObject tipo no seu programa para declarar uma instância do objeto RemoteObject, como este: C# static void Main() { // This code creates an instance of RemoteObject, assuming HelloWorldRemote has been added as a reference: HelloWorldRemote.RemoteObject o = new HelloWorldRemote.RemoteObject(); }
COMO: Criar e usar um domínio de aplicação (Guia de programação C#) Domínios de aplicativo fornecem um método de isolar o código para fins de segurança e desempenho. Para obter mais informações, consulte Domínios de aplicativo (guia de programação C#). Usando um domínio de aplicativo
Visual C# Consolidado
393
1.
Criar o domínio de aplicativo. O host Runtime de idioma comum cria um domínio de aplicativo para automaticamente seu aplicativo. Para informações, consulte o tópico Como: Criar um domínio de aplicativo.
2.
Configure o domínio de aplicativo. Para obter mais informações, consulte Como Configurar um Domínio de Aplicativo.
3.
Carregar um conjunto no domínio de aplicativo. Para obter mais informações, consulte Como Carregar Assemblies em um Domínio de Aplicativo.
4.
Acessar o Conteúdo do outro conjunto. Para obter mais informações, consulte Executar código em outro domínio de aplicação (Guia de programação C#).
5.
Descarregar o domínio do aplicativo. Para obter mais informações, consulte Como: Descarregar um domínio de aplicativo.
Exemplos do Visual C# Você pode acessar código de exemplo, procurando resumos de exemplo nesta seção. Cada abstrato contém um link para abrir ou copiar o exemplo na arquivos. Além disso, o SDK do .NET Framework inclui tecnologia e aplicativo Exemplos e tutoriais QuickStart que demonstram recursos .NET Framework e código Visual C#. Os tutoriais QuickStart são a maneira mais rápida para entender o que a tecnologia .NET Framework oferece desenvolvedores líder-borda. Os QuickStarts são uma série de exemplos e suporte documentação projetadas para rapidamente acquaint você com a sintaxe, arquitetura, e poder do Visual Studio e o .NET Framework. Do ASP.NET Os tutoriais QuickStart inclui exemplos na e aplicativos Windows Forms, além de muitos aplicativos instrução que abrangem os recursos da tecnologia .NET Framework mais atraentes. Para acessar o QuickStarts, clique em Start, aponte para Programs, aponte para Microsoft .NET Framework SDK v2.0, e clique em QuickStart Tutorials. Uma página da Web do aplicativo " tutoriais QuickStart SDK Microsoft .NET Framework " é exibida. Para executar o QuickStarts, siga as instruções na página, que configura o banco de dados amostras e conclui a instalação. Para obter mais informações, consulte Amostras e QuickStarts. Nesta seção Exemplos de introdução Anônimo exemplo representantes
Demonstra o uso de representantes para reduzir a complexidade de aplicativos sem nome.
Exemplo matrizes
Mostra como usar matrizes.
Coleção exemplo classes
Mostra como fazer classes coleção Generic não-que podem ser usados com a foreach instrução.
Exemplo generics (C#)
Mostra como fazer classes a coleção genérica que podem ser usados com a foreach instrução.
Exemplo de parâmetros Demonstra simples processamento de linha de comando e matriz da linha de comando indexação. Exemplo dos Métodos condicional
Demonstra condicionais métodos, que fornecem um poderoso mecanismo pelo qual chamadas para métodos podem ser incluídos ou omitido dependendo se um símbolo é definido.
Exemplo representantes Mostra como representantes são declaradas, mapeado, e combinados. Exemplo eventos
Mostra como usar eventos em C#.
Visual C# Consolidado
394
Exemplo de implementação de interface explícita
Demonstra como explicitamente implementar membros de interface.
Exemplo World de saudação
Um aplicativo hello world.
Exemplo indexadores
Mostra como usar notação de matriz para acessar um objeto.
Indexado exemplo propriedades
Mostra como a implementar uma classe que usa propriedades indexadas. Propriedades indexadas permitem que você para usar uma classe que representa uma coleção de vários tipos diferentes de itens semelhantes matriz-.
Exemplo propriedades
Mostra como propriedades são declaradas e usados; também demonstra propriedades abstratas.
Exemplo Structs
Mostra como usar structs em C#.
Exemplo Overloading do operador
Mostra como definido pelo usuário classes poderá sobrecarregar operadores.
Exemplo Conversions definidas pelo usuário
Mostra como definir conversões de e para tipos definidos pelo usuário.
Exemplo de versão
Do override demonstra versão em C# através do uso de e new palavras-chave.
Produzir exemplo
Demonstra a palavra-chave rendimento para filtrar itens em uma coleção.
Exemplos intermediário e Avançado Exemplo atributos
Mostra como criar classes de atributo personalizado, usá-los em código, e consultá-los através de reflexão.
Exemplo parte 1 Interop COM
Mostra como usar C# para interoperar com objetos COM.
Exemplo parte 2 Interop COM
Mostra como um servidor use um C# com um cliente com C++.
Exemplo bibliotecas
Mostra como usar opções do compilador para criar uma DLL de vários arquivos de origem; além disso, como usar a biblioteca em outros programas.
Exemplo anulável
Demonstra tipos de valores que podem ser definidos como nulo.
Exemplo BD OLE
Demonstra como usar um banco de dados do Microsoft Access do C#. Ele mostra como você pode criar um DataSet e adicionar tabelas a ela a partir de um banco de dados.
Exemplo tipos parcial Demonstra como classes e estruturas podem ser definidas em vários arquivos código fonte-C#. Plataforma Invoke exemplo
Mostra como chamar exportadas funções DLL do C#.
Exemplo de segurança
Discute a segurança do .NET Framework e mostra duas maneiras de modificar as permissões de segurança em C#: Usando classes de permissão e atributos de permissão.
Visual C# Consolidado
395
Segmentação de exemplo
Demonstra várias atividades do segmento, como criando e executando um segmento, sincronizando segmentos, interagir entre segmentos, e usando um pool de segmentos.
Exemplo de código não seguros
Mostra como usar ponteiros.
Exemplo de documentação XML
Mostra como a documentar código usando XML.
Visual C# Consolidado
396
.NET Framework (Como Fazer em C#) Esta página contém links para a Ajuda sobre tarefas do .NET Framework amplamente usadas. Para ver outras categorias de tarefas populares abordadas na Ajuda, consulte Como Fazer em C#. Gerais Introdução à Linguagem C# e ao .NET Framework Descreve o relacionamento entre a linguagem C# e as bibliotecas de classe do .NET Framework e o mecanismo de execução de tempo de execução. Visão Geral sobre o .NET Framework Fornece uma visão geral conceitual dos recursos chave do .NET Framework, incluindo o Common Language Runtime, a biblioteca de classes do .NET Framework e a interoperabilidade entre linguagens. Localizador Rápido de Tecnologia Fornece uma referência rápida para as principais áreas de tecnologia do .NET Framework. E/S de Arquivo Como Criar uma Listagem de Diretório Cria um novo diretório. Como Ler de e Escrever em um Arquivo de Dados Recém-criado Lê de e escreve em um arquivo de dados recém-criado. Como Abrir e Anexar em um Arquivo de Log Abre e anexa em um arquivo de log. Como Escrever Texto em um Arquivo Escreve texto em um arquivo. Como Ler Texto de um Arquivo Lê texto de um arquivo. Como Ler Caracteres de uma Seqüência de Caracteres Lê caracteres de uma seqüência de caracteres. Como Escrever Caracteres em uma Seqüência de Caracteres Escreve caracteres em uma seqüência de caracteres.
Visual C# Consolidado
397
Como Adicionar ou Remover Entradas da Lista de Controle de Acesso Adiciona ou remove entradas da Lista de Controle de Acesso (ACL) para aumentar a segurança. Seqüências de Caracteres Criando Novas Seqüências de Caracteres Como criar uma nova seqüência de caracteres. Aparando e Removendo Caracteres Como remover caracteres do início ou do final de uma seqüência de caracteres. Preenchendo Seqüências de Caracteres Como adicionar tabulações ou espaços ao início ou ao final de seqüências de caracteres. Comparando Seqüências de Caracteres Como verificar a igualdade de duas seqüências de caracteres. Alterando a Caixa Como alterar letras em maiúsculo para letras em minúsculo e visse-versa. Usando a Classe StringBuilder Técnicas eficientes de manipulação de seqüências de caracteres. Como Executar Manipulações sobre Seqüência de Caracteres Usando Operações Básicas Como dividir seqüências, acrescentar uma seqüência a outra e mais. Como Converter Tipos de Dados Usando System.Convert Contém um exemplo que usa a classe Convert para transformar um valor string em um valor booleano. Como Remover Caracteres Inválido de uma Seqüência de Caracteres Contém um exemplo que usa o método estático Regex.Replace para remover caracteres inválidos de uma seqüência de caracteres. Como Verificar se Seqüências de Caracteres Estão em um Formato de Email Válido Contém um exemplo que usa o método estático Regex.IsMatch para verificar se uma seqüências de caracteres está em um formato de email válido. Coleções Coleções e Estruturas de Dados Visão geral das classes de coleção do .NET Framework.
Visual C# Consolidado
398
Selecionando uma Classe de Coleção Como escolher que tipo de coleção usar. Quando Usar Coleções Genéricas Explica as vantagens de classes de coleção genéricas sobre classes coleção nãogenéricas. System.Collections.Generic Página de portal das classes da coleção genéricas. List Fornece exemplos de código mostrando como adicionar e remover itens de uma coleção List. SortedDictionary Fornece exemplos de código mostrando como adicionar e remover pares chave/valor de uma coleção SortedDictionary. Exceções Como Usar Exceções Específicas em um Bloco Catch Contém um exemplo que usa um bloco try/catch para captura uma InvalidCastException. Como Usar o Bloco Try/Catch para Capturar Exceções Contém um exemplo que usa um bloco try/catch para capturar uma possível exceção. Como Criar Exceções Definida pelo Usuário Contém um exemplo onde uma nova classe de exceção, EmployeeListNotFoundException, é derivada de Exception. Como Usar Blocos Finally Contém um exemplo que usa um bloco try/catch para capturar uma exceção ArgumentOutOfRangeException. Como Lançar Exceções Explicitamente Contém um exemplo que usa um bloco try/catch para detectar uma possível exceção FileNotFoundException. Eventos Como Consumir Eventos em um Aplicativo do Windows Forms Contém exemplos que mostram como tratar um evento de clique botão em um Windows Form. Como Conectar Métodos de Manipulação de Eventos a Eventos
Visual C# Consolidado
399
Contém exemplos que mostram como adicionar um método que manipula um evento a um evento. Como Gerar e Consumir Eventos Contém um exemplo que usa conceitos descritos em detalhes em Eventos e Delegates e Gerando um Evento. Como Manipular Vários Eventos Usando Propriedades de Evento Contém um exemplo que mostrar como manipular vários eventos usando propriedades de evento. Como Implementar Eventos em sua Classe Contém procedimentos que descrevem como implementar um evento em uma classe. Depuração Consulte Depuração (Como Fazer em C#). Implantação Consulte Segurança (Como Fazer em C#). Serviced Components Como Criar um Gerenciador de Recursos de Compensação (CRM) Inclui exemplos de código para mostrar como criar um Gerenciador de Recursos de Compensação Como Criar um Serviced Component Contém um procedimento que descreve como criar um novo serviced component. Como Aplicar o Atributo Description a um Assembly Mostra como aplicar o atributo DescriptionAttribute para definir a descrição de um assembly. Como Usar os Métodos SetAbort e SetComplete Mostra como usar os métodos estáticos SetComplete e SetAbort da classe ContextUtil. Como Aplicar o Atributo ApplicationID a um Assembly Mostra como aplicar o atributo ApplicationID a um assembly. Como Criar um Objeto de Pool e Definir seus Limites de Tamanho e de Tempo Mostra como criar um objeto de pool e definir seus limites de tamanho e de tempo. Como criar um Método de Web Service que Usa Transações Automáticas
Visual C# Consolidado
400
Descreve como criar um método de Web Service que usa transações automáticas. Como Definir a Propriedade SoapRoot Property para um Aplicativo Mostra como definir a propriedade SoapVRoot como "MyVRoot". Como Definir o Tempo Limite da Transação Mostra como configurar o tempo limite da transação para 10 segundos. Como Definir o Nome do Aplicativo Usando o Atributo ApplicationName Mostra como fornecer o nome do aplicativo usando o atributo ApplicationName a nível de assembly. Como Usar o Recurso BYOT (Bring Your Own Transaction - Traga sua Própria Transação) do COM+ Contém procedimentos que mostram como uma classe derivada da classe ServicedComponent pode usar o recurso BYOT do COM+ para acessar um coordenador de transações distribuídas (DTC). Como Criar um Componente Privado Mostra como usar o atributo PrivateComponentAttribute em uma classe. Como Definir o Tipo de Ativação de um Aplicativo Mostra como definir o tipo de ativação para "server". Como Habilitar Sincronização em Instâncias de uma Classe Mostra como para habilitar sincronização em instâncias da classe TestSync. Como Usar Transações Automáticas em uma Classe do .NET Framework Descreve como preparar uma classe para participar de uma transação automática. Como Habilitar Ativação JIT Mostra como habilitar ativação e desativação JIT dentro e fora de uma classe. Como Definir o Atributo AutoComplete em uma Classe Transaction-Aware Mostra o posicionamento do atributo AutoComplete em uma classe transaction-aware. Como Implementar um Componente Enfileirado que Exibe uma Mensagem de Forma Assíncrona Demonstra como implementar um componente enfileirado que exibe uma mensagem de forma assíncrona. Como Implementar Eventos Fracamente Acoplados
Visual C# Consolidado
401
Contém procedimentos que mostram como implementar uma classe de eventos e um coletor de eventos que implementam uma interface de eventos comum e mais um publisher para acionar o evento. Como Configurar a Construção de Objetos Contém um procedimento e um exemplo que descrevem como configurar a construção de objetos e definir a seqüência de inicialização padrão da classe TestObjectConstruct para a seqüência "Initial Catalog=Northwind;Data Source=.\\SQLServerInstance;Trusted_Connection=yes". Assemblies e Domínios de Aplicativos Como Obter Informações de Tipo e Membros de um Assembly Contém um exemplo que obtém informações de tipo e membro de um assembly. Como Criar um Assembly de Arquivo Único Contém um procedimento que mostra como criar assemblies de arquivo único usando compiladores de linha de comando. Como criar um Domínio de Aplicativo Cria um novo domínio de aplicativo, atribui o nome MyDomain e, em seguida, imprime no console o nome do domínio do host e do domínio do aplicativo filho recém-criado. Como Determinar o Nome Totalmente Qualificado de um Assembly Mostra como exibir o nome totalmente qualificado de um assembly contendo uma classe especificada para o console. Como Configurar um Domínio de Aplicativo Cria uma instância da classe AppDomainSetup, usa essa classe para criar um novo domínio de aplicativo, escreve as informações no console e descarrega o domínio de aplicativo. Como Visualizar o Conteúdo de um Assembly Contém um exemplo que começa com um programa "Hello, World " básico e mostra como usar ILDASM.exe para desmontar o assembly Hello.exe e exibir o manifesto do assembly. Como Referenciar um Assembly de Nome Forte Cria um assembly chamado myAssembly.dll que referencia um assembly de nome forte chamado myLibAssembly.dll a partir de um módulo de código chamado myAssembly.CS. Como Descarregar um Domínio de Aplicativo Cria um novo domínio de aplicativo chamado MyDomain, imprime algumas informações no console e, em seguida, descarrega o domínio de aplicativo. Como Remover um Assembly de Cache Global de Assemblies
Visual C# Consolidado
402
Contém um exemplo que remove um assembly chamado Hello.dll da cache global de assemblies. Como Instalar um Assembly na Cache Global de Assemblies Contém um exemplo que instala um assembly chamado Hello.dll na cache global de assemblies. Como Criar um Assembly de Múltiplos Arquivos Descreve o procedimento usado para criar um assembly de múltiplos arquivos e fornece um exemplo completo que ilustra cada uma das etapas do procedimento. Como Carregar Assemblies em um Domínio de Aplicativo Contém um exemplo que carrega um assembly no domínio de aplicativo atual e, em seguida, executa o assembly. Como Assinar um Assembly com um Nome Forte Contém um exemplo que assina o assembly MyAssembly.dll com um nome forte usando o arquivo chave sgKey.snk. Como Visualizar o Conteúdo da Cache Global de Assemblies Mostra como usar a ferramenta Global Assembly Cache (Gacutil.exe) para exibir o conteúdo da cache global de assemblies. Como Criar um par de chaves Public/Private Mostra como assinar um assembly com um nome forte e como criar um par de chaves usando a ferramenta Strong Name (Sn.exe). Interoperação Como Incorporar Bibliotecas de Tipo como Recursos Win32 em Aplicativos Baseados no .NET Mostra como incorporar uma biblioteca de tipos como um recurso Win32 em um aplicativo baseado no .NET Framework. Como Gerar Assemblies de Interoperabilidade Primários Usando Tlbimp.exe Fornece exemplos que mostram como gerar assemblies de interoperabilidade primários usando Tlbimp.exe. Como Criar Assemblies de Interoperabilidade Primários Manualmente Fornece um exemplo que mostra como criar assemblies de interoperabilidade primários manualmente. Como Gerar Assemblies de Interoperabilidade a partir de Bibliotecas de Tipo Fornece exemplos que mostram como gerar um assemblies de interoperabilidade a partir de uma biblioteca tipo.
Visual C# Consolidado
403
Como Gerar Eventos Manipulados por um Coletor COM Fornece um exemplo que mostra um servidor gerenciado como a fonte do evento e um cliente COM como o coletor do evento. Como Personalizar Wrappers Invocáveis em Tempo de Execução Mostra como personalizar wrappers invocáveis em tempo de execução modificando a fonte IDL ou modificando um assembly importado. Como Configurar Componentes Baseado em .NET para Habilitar Livre Registro Explica como configurar componentes baseados no .NET Framework para habilitar Livre Registro Como Implementar Funções CallBack Demonstra como um aplicativo gerenciado, usando invocação de plataforma, pode imprimir o valor de identificador para cada janela do computador local Como Mapear HRESULTs e Exceções Contém um exemplo que mostra como criar uma nova classe de exceção chamada NoAccessException e mapeá-la ao HRESULT E_ACCESSDENIED. Como Editar Assemblies de Interoperabilidade Demonstra como especificar alterações de empacotamento na Microsoft Intermediate Language (MSIL). Como Adicionar Referências a Bibliotecas de Tipo Explica as etapas para adicionar uma referência a uma biblioteca de tipos. Como Manipular Eventos Gerados por uma Fonte COM Inclui um exemplo que demonstrar como abrir uma janela do Internet Explorer e como amarrar eventos gerados pelo objeto InternetExplorer a manipuladores de eventos implementados em código gerenciado. Como Criar Wrappers Manualmente Mostra um exemplo da interface ISATest e da classe SATest em IDL e os tipos correspondentes no código fonte C#. Como Registrar Assemblies de Interoperabilidade Primários Inclui um exemplo que mostra como registrar o assembly de interoperabilidade primário CompanyA.UtilLib.dll. Como Empacotar Várias Versões de Bibliotecas de Tipos Explica como empacotar mais de uma versão de uma biblioteca de tipos. Segurança
Visual C# Consolidado
404
Consulte Segurança (Como Fazer em C#). Serialização Como Desserializar um Objeto Fornece um exemplo que desserializa um objeto em um arquivo. Como Usar Ferramenta de Definição de Esquema XML para Gerar Classes e Documentos de Esquema XML Fornece procedimentos para mostrar como usar a ferramenta de definição de esquema XML para gerar classes e documentos de esquema XML. Como Especificar um Nome de Elemento Alternativo para um Fluxo XML Mostra como você pode gerar mais de um fluxo de XML com o mesmo conjunto de classes. Como Controlar a Serialização de Classes Derivadas Fornece um exemplo que mostrar como controlar a serialização de classes derivadas. Como Serializar um Objeto como um Fluxo XML de Codificação SOAP Fornece um procedimento e um exemplo para serializar um objeto como um fluxo de XML de Codificação SOAP. Como Particionar Dados Serializados Fornece um procedimento e um exemplo para implementar particionamento do lado do servidor e processamento do lado do cliente. Como Serializar um Objeto Fornece um procedimento para serializar um objeto. Como Qualificar um Elemento XML e Nomes Atributos XML Fornece um procedimento e um exemplo para criar nomes qualificados em um documento XML. Como Substituir a Serialização SOAP XML Codificada Fornece um procedimento e um exemplo para substituir serialização de objetos como mensagens SOAP. Codificação e Localização Como Analisar Dígitos Unicode Fornece um exemplo que usa o método Decimal.Parse para analisar seqüências de caracteres de valores Unicode que especificam dígitos em scripts diferentes.
Visual C# Consolidado
405
Como Criar Culturas Personalizadas Fornece um procedimento para definir e criar um cultura personalizada. Programação Avançada Como Definir e Executar Métodos Dinâmicos Mostra como definir e executar um método dinâmico simples e um método dinâmico ligado a uma instância de uma classe. Como Examinar e Instanciar Tipos Genéricos com Reflexão Fornece procedimentos que mostram como descobrir e manipular tipos genéricos. Como Definir um Método genérico com Emissão de Reflexão Fornece procedimentos que mostram como definir um método genérico com emissão de reflexão. Como Usar Assinatura Completa para Dar a um Assembly Dinâmico um Nome Forte Demonstra o uso de assinatura completa para dar um assembly dinâmico um nome forte. Como Carregar Assemblies no Contexto Somente de Reflexão Fornece um procedimento e um exemplo de código para mostrar como carregar assemblies no contexto somente de reflexão. Como Definir um Tipo Genérico com Emissão de Reflexão Mostra como criar um tipo genérico simples com dois parâmetros de tipo, como aplicar restrições de classe, restrições de interface e restrições especiais aos parâmetros de tipo e como criar membros que usam os parâmetros de tipo de uma classe como tipos de parâmetros e tipos de retorno. Explicações Passo-a-passo do .NET Framework SDK Passo-a-passo: Adicionando Marcas Inteligentes a um Componente do Windows Forms Demonstra como adicionar marcas inteligentes usando código de um controle de exemplo simples, ColorLabel, que é derivado do controle padrão Windows Forms Label Passo-a-passo: Alterando a Mensagem SOAP Usando Extensões SOAP Mostra como criar e executar uma extensão SOAP. Passo-a-passo: Construindo um XML Web Service Básico Usando ASP.NET Demonstra como criar um XML Web Services básico usando ASP.NET. Passo-a-passo: Personalização para Dispositivos Específicos Demonstra como personalizar dispositivos específicos. Passo-a-passo: Personalizando a Geração de Descrições de Serviços e Classes Proxy
Visual C# Consolidado
406
Demonstra como personalizar a geração de descrições de serviços e classes proxy. Passo-a-passo: Implantando um Aplicativo ClickOnce Manualmente Descreve as etapas necessárias para criar uma implantação ClickOnce completa usando a versão de linha de comando ou gráfica da ferramenta de Geração e Edição de Manifesto (Manifest Generation and Editing - Mage). Passo-a-passo: Fazendo o Download de Assemblies por Demanda com a API de Implantação do ClickOnce Demonstra como marcar determinados assemblies em seu aplicativo como "optional" (opcional) e como fazer o download dos mesmos usando classes no namespace System.Deployment.Application quando a Common Language Runtime (clr) os requer. Passo-a-passo: Implementando um Editor de Tipos de Interface do Usuário Explica como criar seu próprio editor de tipos de interface do usuário para um tipo personalizado e como exibir a interface de edição usando um PropertyGrid. Recursos adicionais Visual Studio 2005 Developer Center Contém vários artigos e recursos sobre o desenvolvimento de aplicativos usando o Visual Studio 2005. Este site é atualizado regularmente com novos conteúdos. Visual C# Developer Center Contém vários artigos e recursos sobre o desenvolvimento de aplicativos em C#. Este site é atualizado regularmente com novos conteúdos. Microsoft .NET Framework Developer Center Contém vários artigos e recursos sobre desenvolvimento e a depuração de aplicativos no .NET Framework. Este site é atualizado regularmente com novos conteúdos.
Visual C# Consolidado
407
Introdução à linguagem C# e ao .NET Framework C# é uma linguagem elegante orientada a objetos e fortemente tipada que permite aos desenvolvedores criar uma ampla variedade de aplicativos seguros e eficientes que são executados sob o .NET Framework. Você pode usar C# para criar aplicativos clientes tradicionais do Windows , XML Web services, componentes distribuídos, aplicativos cliente-servidor, aplicativos de banco de dados, e muito, muito mais. Microsoft Visual C# 2005 fornece um editor de código avançado, designers de interface de usuário convenientes, depurador integrado, e muitas outras ferramentas para facilitar o rápido desenvolvimento de aplicativos com base na versão 2.0 da linguagem C# e do .NET Framework. Observação A documentação Visual C# presume que você tenha uma compreensão dos conceitos básicos existentes de programação. Se você for um completo principiante, convém explorar Visual C# Express Edition, que está disponível na Web. Você também pode aproveitar qualquer um dos diversos livros excelentes e recursos da Web em C# para aprender técnicas de prática de programação. Linguagem C# A sintaxe C# é altamente expressiva, mas com menos de 90 palavras-chave, também é simples e fácil para aprender. A sintaxe do C# utilizando chaves como marcador de blocos será instantaneamente reconhecível para qualquer pessoa familiarizada com C, C++ ou Java. Os desenvolvedores que conhecem qualquer uma dessas linguagens são normalmente capazes de começar a trabalhar produtivamente em C# dentro de muito pouco tempo. A sintaxe C# simplifica muitas das complexidades de C++ enquanto fornece recursos poderosos como tipos de valor anulável, enumerações, delegações, métodos anônimos e acesso direto à memória, que não foram localizados em Java. C# também oferece suporte a métodos e tipos genéricos, que fornecem aumento de segurança e desempenho, e iteradores, que permitem implementadores das classes de coleção definirem comportamentos personalizados da iteração que são simples para usar pelo código do cliente. Como uma linguagem orientada a objetos, C# suporta os conceitos de encapsulamento, herança e polimorfismo. Todas as variáveis e métodos, incluindo o método Main, ponto de entrada do aplicativo, são encapsulados em definições da classe. Uma classe pode herdar diretamente de uma classe pai, mas ela pode implementar qualquer número de interfaces. Métodos que substituem métodos virtuais em uma classe pai exigem a palavra-chave override como uma forma para evitar redefinição acidental. No C#, uma estrutura é como uma classe simplificada; ele é um tipo alocado na pilha que pode implementar interfaces mas não tem suporte a herança. Além desses princípios orientados a objetos, C# facilita o desenvolvimento de componentes de software através de vários construtores inovadores da linguagem, incluindo: •
Assinaturas de métodos encapsulados chamadas delegações, que permitem notificações de eventos fortemente tipados.
•
Propriedades, que servem como accessadores de variáveis membros privadas.
•
Atributos, que fornecem metadados declarativos sobre tipos no tempo de execução.
•
Comentários internos da documentação XML.
Se você precisar interagir com outro software Windows como objetos COM ou DLLs nativas Win32, você pode fazer isso em C# através de um processo denominado "Interoperabilidade".
Visual C# Consolidado
408
Interoperabilidade permite que programas C# façam praticamente tudo que um aplicativo C++ nativo pode fazer. C# também suporta ponteiros e o conceito de código "inseguro" para os casos no qual o acesso direto a memória é absolutamente essencial. O processo de compilação C# é simples comparado ao C e C++ e mais flexível do que em Java. Não há nenhum arquivo cabeçalho separado, e nenhum requisito de que métodos e tipos sejam declarados em uma ordem específica. Um arquivo fonte C# pode definir qualquer número de classes, estruturas, interfaces, e eventos. Estes são recursos adicionais do C#: •
Para uma boa introdução geral da linguagem, consulte o Capítulo 1 da Especificação da Linguagem C#.
•
Para obter informações detalhadas sobre aspectos específicos da linguagem C#, consulte a Referência C#.
•
Para uma comparação da sintaxe C# com a de Java e C++, consulte A linguagem de programação C# para desenvolvedores Java e Comparação entre C++ e C#.
Arquitetura da plataforma .NET Framework Programas C# são executados no .NET Framework, um componente integrante do Windows que inclui um sistema de execução virtual chamado de Common Language Runtime (CLR) e um conjunto unificado de bibliotecas de classe. O CLR é implementação comercial da Microsoft do Common Language Infrastructure (CLI), um padrão internacional que é a base para criar ambientes de execução e desenvolvimento nos quais linguagens e bibliotecas trabalham perfeitamente juntas. Código fonte escrito em C# é compilado em uma linguagem intermediária (IL) que está em conformidade com a especificação CLI. O código IL, juntamente com recursos como bitmaps e seqüências de caracteres, é armazenado em disco em um arquivo executável chamado de assembly, normalmente com uma extensão .exe ou .dll. Um assembly contém um manifesto que fornece informações sobre tipos do assembly, versão, cultura, e requisitos de segurança. Quando o programa C# é executado, o módulo (assembly) é carregado no CLR, que pode levar a várias ações com base nas informações no manifesto. Em seguida, se os requisitos de segurança forem atendidos, o CLR executa a compilação Just-In-Time (JIT) para converter o código IL em instruções nativas da máquina. O CLR também oferece outros serviços relacionados a coleta de lixo automática, tratamento de exceção, e gerenciamento de recursos. Código que é executado pelo CLR é as vezes conhecido como "código gerenciado", em contraste com "código não gerenciado" que é compilado em linguagem de máquina nativa que atinge um sistema específico. O diagrama a seguir ilustra os relacionamentos entre o tempo de compilação e o tempo de execução dos arquivos de código fonte C#, as bibliotecas de classes base, módulos (assemblies), e o CLR.
Visual C# Consolidado
409
A interoperabilidade da linguagem é um recurso chave do .NET Framework. Por estar em conformidade com o Common Type Specification (CTS), o código IL produzido pelo compilador C# pode interagir com código que foi gerado a partir das versões .NET do Visual Basic, Visual C++, Visual J#, ou qualquer uma das outras mais de 20 linguagens CTS-Compliant. Um conjunto único pode conter vários módulos escritos em linguagens .NET diferentes, e os tipos podem se referenciar como se eles fossem escritos na mesma linguagem. Além dos serviços de tempo de execução, o .NET Framework também inclui uma biblioteca abrangente com mais de 4000 classes organizadas em namespaces que fornecem uma variedade de funcionalidades úteis para tudo desde entrada e saída de arquivo até manipulação de seqüência para análise XML e controles de Windows Forms. Uma aplicação C# típica usa amplamente a biblioteca de classe do .NET Framework para manipular tarefas comuns de "conexões internas". Para obter mais informações sobre a plataforma .NET Framework, consulte Visão geral sobre o .NET Framework.
Visão geral sobre o .NET Framework Esta seção fornece uma visão geral conceitual dos recursos chave do .NET Framework, incluindo o Common Language Runtime, a biblioteca de classes do .NET Framework, e interoperabilidade entre linguagens.
Visão Geral Conceitual Sobre o .NET Framework O .NET Framework é um componente integral do Windows que oferece suporte à criação e execução da próxima geração de aplicativos e Serviços XML da Web. O .NET Framework foi criado para atender os seguintes objetivos:
Visual C# Consolidado
410
•
Para fornecer um ambiente de programação orientada a objetos consistente, se o código objeto for armazenado e executado localmente, executado localmente mas distribuído pela Internet ou executado remotamente.
•
Para fornecer um ambiente da execução de código que minimiza conflitos de implantação e versionamento de software.
•
Para fornecer um ambiente da execução que promova a execução segura do código, incluindo o código criado por terceiros: desconhecidos ou semi-confiáveis.
•
Para fornecer um ambiente da execução que elimina os problemas de desempenho dos ambientes interpretados ou com scripts.
•
Para tornar a experiência do desenvolvedor consistente, através dos diversos tipos de aplicativos, como aplicativos baseados no Windows e aplicativos baseados na Web.
•
Para criar todas as comunicações nas indústrias padrão, para garantir que códigos baseados no .NET Framework possam se integrar a qualquer outro código.
O .NET Framework tem dois componentes principais: o Common Language Runtime e a biblioteca de classes do .NET Framework. O Common Language Runtime é a fundação do .NET Framework. Você pode pensar no Runtime como um agente que dirige o código no tempo de execução, fornecendo serviços principais como gerenciamento de memória, gerenciamento de segmento e arquitetura de comunicação remota, enquanto forçam, também, a segurança de tipos estritos e outras formas de precisão de código que promovem segurança e robustez. Na verdade, o conceito de gerenciamento de código é um princípio fundamental do Runtime. O código que visa o Runtime é conhecido como código gerenciado, enquanto o código que não visa o Runtime é conhecido como código não gerenciado. A biblioteca de classes, outro componente principal do .NET Framework, é uma coleção de objetos orientados de tipos reutilizáveis, que você pode usar para desenvolver aplicativos, variando de linhas de comando tradicionais ou aplicativos gráficos de interfaces de usuários (GUI), para aplicativos com base nas inovações mais recentes fornecidas pelo ASP.NET, como Web Forms e Serviços XML da Web. O .NET Framework pode ser hospedado por componentes não gerenciados que carregam o Common Language Runtime em seus processos, e inicializam a execução de código gerenciado. Assim, criam um ambiente de software que pode explorar os recursos gerenciados e não gerenciados. O .NET Framework não apenas fornece vários Runtime Hosts, como também suporta o desenvolvimento de Runtime Hosts de terceiros. Por exemplo, o ASP.NET hospeda o Runtime para fornecer um ambiente escalonável, do lado do servidor, para código gerenciado. ASP.NET trabalha diretamente com o tempo de execução para ativar os aplicativos ASP.NET e Serviços XML da Web, ambos serão discutidos posteriormente neste tópico. Internet Explorer é um exemplo de um aplicativo não gerenciado que hospeda o Runtime (na forma de uma extensão tipo MIME). Usar o Internet Explorer para hospedar o Runtime, permite que você incorpore componentes gerenciados ou controles Windows Forms em documentos HTML. Hospedar o Runtime dessa maneira, torna possível o gerenciamento do código móvel (semelhante a controles Microsoft® ActiveX®), mas com melhorias significativas que somente o código gerenciado pode oferecer, como execução semi-confiável e armazenamento de arquivos isolados. A ilustração a seguir mostra o relacionamento do Common Language Runtime e da biblioteca de classes para seus aplicativos e para o sistema geral. A ilustração também mostra como o código gerenciado opera dentro uma arquitetura maior. NET Framework em contexto
Visual C# Consolidado
411
As seções a seguir descrevem os recursos e componentes principais do .NET Framework com mais detalhes. Recursos do Common Language Runtime O Common Language Runtime gerencia memória, execução de segmento, execução do código, verificação de segurança do código, compilação e outros serviços do sistema. Esses recursos são intrínsecos para o código gerenciado, que executa no Common Language Runtime. Quanto à segurança, os componentes gerenciados são concedidos variando os graus da confiança, dependendo do número de fatores que incluem sua origem (como a Internet, rede corporativa ou computador local). Isso significa que um componente gerenciado pode ou não ser capaz de executar operações de acesso de arquivo, operações de registro de acesso ou outras funções confidenciais, mesmo se ele estiver sendo usado no mesmo aplicativo ativo. O Runtime impõe segurança de acesso a código. Por exemplo, os usuários podem confiar que um executável, incorporado em uma página da Web, pode reproduzir uma animação na tela ou tocar uma música, mas não pode acessar seus dados pessoais, arquivos de sistema ou rede. Os recursos de segurança do Runtime ativam o legítimo Internet-deployed software para ser caracterizado, excepcionalmente, como rico. O Runtime também impõe robustez ao código ao implementar uma estrita infra-estrutura Typeand-Code-Verification chamada Common Type System (CTS). O CTS assegura que todo código gerenciado é autodescritivo. Os diversos compiladores de linguagem da Microsoft e de terceiros geram códigos gerenciados que estão em conformidade com o CTS. Isso significa que códigos gerenciados podem consumir outros tipos gerenciados e instâncias, enquanto forçam estritamente a fidelidade tipo e segurança. Além disso, o ambiente gerenciado do Runtime elimina muitos problemas comuns de software. Por exemplo, o Runtime automaticamente manipula o layout de objetos e gerencia referências a eles, liberando-os quando não estão sendo usados. Este gerenciamento automático de memória resolve os dois erros mais comuns de aplicativos: vazamentos e referências inválidas de memória. O Runtime também acelera a produtividade do desenvolvedor. Por exemplo, os programadores podem escrever aplicativos em sua linguagem de desenvolvimento de preferência, mas aproveitar completamente o Runtime, a biblioteca de classes e componentes escritos em outras linguagens, por outros desenvolvedores. Qualquer fornecedor de compilador que escolher direcionar o Runtime pode fazê-lo. Compiladores de linguagem que direcionam o .NET Framework tornam os recursos do .NET Framework disponíveis para códigos existentes, escritos nessa linguagem, facilitando bastante o processo de migração para os aplicativos existentes. O Runtime foi criado para o software do futuro, mas também suporta software atuais. Interoperabilidade entre códigos gerenciados e não gerenciados permite aos desenvolvedores continuar a usar os componentes COM e DLLs necessários. O Runtime é projetado para melhorar o desempenho. Embora o Common Language Runtime forneça vários serviços padrão de Runtime, o código gerenciado nunca é interpretado. Um recurso chamado compilação Just-In-Time (JIT) ativa todos os códigos gerenciados para executar na linguagem nativa da máquina do sistema, no qual ele estiver em execução. Enquanto isso, o gerenciador de memória remove as possibilidades de memória fragmentada e aumenta a localidade-de-referência da memória, melhorando ainda mais o desempenho. Finalmente, o Runtime pode ser hospedado por aplicativos de alto desempenho, do lado do servidor, como o Microsoft ® SQL Server ™ e Serviços de Informações da Internet (IIS). Esta infra-estrutura permite que você use código gerenciado para escrever sua lógica corporativa,
Visual C# Consolidado
412
enquanto aproveita o desempenho superior dos melhores servidores de empresa que suportam runtime hosting. Biblioteca de Classes do .NET Framework A Biblioteca de classes do .NET Framework é uma coleção de tipos reutilizáveis que se integram rigidamente com o Common Language Runtime. A biblioteca de classes é orientada a objetos, fornecendo tipos que seu próprio código gerenciado pode derivar. Isso não só torna os tipos do .NET Framework fáceis de usar, como também reduz o tempo associado ao aprendizado de novos recursos do .NET Framework. Além disso, componentes de terceiros podem se integrar totalmente com classes do .NET Framework. Por exemplo, as classes da coleção .NET Framework implementam um conjunto de interfaces que você pode usar para desenvolver suas próprias coleções de classes. Sua coleção de classes será perfeitamente combinada com as classes do .NET Framework. Como você espera de uma biblioteca de classe orientada a objetos, os tipos do .NET Framework permitem que você realize uma gama de tarefas comuns de programação, incluindo tarefas como gerenciamento de seqüência de caracteres, coleta de dados, conectividade do banco de dados e acesso a arquivos. Além dessas tarefas comuns, a biblioteca de classes inclui tipos que oferecem suporte a uma variedade de cenários especializados de desenvolvimento. Por exemplo, você pode usar o .NET Framework para desenvolver os seguintes tipos de aplicativos e serviços: •
Aplicativos de console.
•
Aplicativos Windows GUI (Windows Forms).
•
Aplicativos ASP.NET.
•
Serviços XML da Web.
•
Serviços do Windows.
Por exemplo, as classes Windows Forms são um conjunto abrangente de tipos reutilizáveis que simplificam vastamente o desenvolvimento do Windows GUI. Se você criar um aplicativo de Web Form ASP.NET, você pode usar as classes Web Forms. Desenvolvimento de Aplicativos Cliente Aplicativos cliente são os mais próximos de um estilo tradicional de um aplicativo baseado em programação Windows. Esses são os tipos de aplicativos que exibem janelas ou formulários na área de trabalho, permitindo a um usuário executar uma tarefa. Aplicativos cliente incluem aplicativos como processadores de texto e planilhas, bem como aplicativos de negócios personalizados, como ferramentas de entrada de dados, ferramentas de relatórios e assim por diante. Aplicativos cliente geralmente empregam janelas, menus, botões e outros elementos GUI. Eles acessam, provavelmente, recursos locais como o sistema de arquivos e periféricos, como impressoras. Outro tipo de aplicativo cliente é o tradicional controle ActiveX (agora, substituído pelo o controle gerenciado do Windows Forms) implantado através da Internet como página da Web. Este aplicativo se parece muito com outros aplicativos clientes: ele é executado de forma nativa, tem acesso a recursos locais e inclui elementos gráficos. No passado, os desenvolvedores criavam esses aplicativos utilizando C/C++ em conjunto com o Microsoft Foundation Classes (MFC) ou com um ambiente de desenvolvimento de aplicativos rápidos (RAD) como o Microsoft ® Visual Basic ®. O .NET Framework incorpora aspectos desses produtos existentes em um ambiente de desenvolvimento simples e consistente, que drasticamente simplifica o desenvolvimento de aplicativos cliente.
Visual C# Consolidado
413
As classes do Windows Forms contidas no .NET Framework são projetadas para serem usadas para o desenvolvimento do GUI. Facilmente, você pode criar janelas de comando, botões, menus, barras de ferramentas e outros elementos de tela, com a flexibilidade necessária para acomodar mudanças de necessidades comerciais Por exemplo, o .NET Framework fornece propriedades simples para ajustar atributos visuais associados a formulários. Em alguns casos o sistema operacional base não dá suporte para alteração direta desses atributos, e nesse caso o .NET Framework automaticamente recria os formulários. Essa é uma das várias maneiras na qual o .NET Framework integra a interface do desenvolvedor, tornando a codificação simples e mais consistente. Diferentemente de controle ActiveX, controles Windows Forms têm acesso semi-confiável ao computador do usuário. Isso significa que execução binária ou nativa de código pode acessar alguns dos recursos do sistema do usuário (como elementos GUI e acesso limitado ao arquivo) sem poder acessar ou comprometer outros recursos. Devido à segurança de acesso ao código, muitos aplicativos que antes necessitavam ser instalados no sistema de um usuário, agora podem ser implantados através da Web. Seus aplicativos podem implementar os recursos de um aplicativo local, enquanto são implantadas como uma página da Web. Desenvolvimento de aplicativos servidores Aplicativos do servidor no mundo gerenciado são implementados através de Runtime Hosts. Aplicativos não gerenciados hospedam o Common Language Runtime, que permite que seu código gerenciado personalizado controle o comportamento do servidor. Esse modelo fornece a você todos os recursos do Common Language Runtime e biblioteca de classes, enquanto ganha o desempenho e escalabilidade do servidor host. A ilustração a seguir mostra um esquema de rede básica com código gerenciado em execução, em ambientes de servidores diferentes. Servidores como o IIS e SQL Server podem executar operações padrão, enquanto a lógica do seu aplicativo executa através do código gerenciado. Código gerenciado do lado do servidor
ASP.NET é o ambiente de hospedagem que permite aos desenvolvedores usar o.NET Framework para direcionar aplicativos baseados na Web. Entretanto, o ASP.NET é mais do que apenas um Runtime Host; ele é uma arquitetura completa para desenvolver sites e objetos InternetDistributed, usando código gerenciado. Web Forms e serviços XML da Web usam IIS e ASP.NET como mecanismos de publicação de aplicativos, e ambos têm uma coleção de classes que são suportadas pelo .NET Framework. Serviços XML da Web, uma evolução importante na tecnologia baseada na Web, são componentes de aplicativos distribuídos, do lado do servidor, semelhante a sites comuns da Web. Entretanto, diferentemente dos aplicativos baseados na Web, componentes de serviços XML da Web não têm interface de usuário, e não são direcionados para navegadores como o Internet Explorer e Netscape Navigator. Em vez disso, serviços XML da Web consistem em componentes de software reutilizáveis, projetados para serem consumidos por outros aplicativos, como aplicativos cliente tradicionais, aplicativos baseados na Web ou mesmo outros serviços XML da Web. Como resultado, a tecnologia dos serviços XML da Web está movendo, rapidamente, o desenvolvimento e implantação de aplicativos para o ambiente altamente distribuído da Internet. Se você utilizou versões anteriores da tecnologia ASP, você imediatamente notará os aperfeiçoamentos que ASP.NET e Web Forms oferecem. Por exemplo, você pode desenvolver páginas Web Forms em qualquer linguagem que suporte o .NET Framework. Além disso, seu código não precisa mais compartilhar o mesmo arquivo com o texto HTTP (embora ele possa
Visual C# Consolidado
414
continuar fazendo isso, se você preferir). Páginas Web Forms executam na linguagem de máquina nativa porque, como qualquer outro aplicativo gerenciado, elas aproveitam completamente o Runtime. Por outro lado, páginas ASP não gerenciadas são sempre colocadas em script e interpretadas. Páginas ASP.NET são mais rápidas, mais funcionais e mais fáceis para desenvolver do que as páginas ASP não gerenciadas, porque elas interagem com o Runtime como qualquer aplicativo gerenciado. O .NET Framework também fornece um conjunto de classes e ferramentas para ajudar no desenvolvimento e consumo de aplicativos de serviços XML da Web. Serviços XML da Web são criados em padrões como SOAP (um protocolo remoto de chamada de procedimento), XML (um formato de dados extensível) e WSDL (Web Services Description Language). O .NET Framework foi construído sobre esses padrões para promover a interoperabilidade com soluções nãoMicrosoft. Por exemplo, a ferramenta WSDL, incluída com o SDK do .NET Framework, pode consultar um serviço XML da Web publicado na Web, analisar sua descrição WSDL e produzir código fonte C# ou Visual Basic, que o aplicativo pode usar para se tornar um cliente do serviço XML da Web. O código fonte pode criar classes derivadas de classes, na biblioteca de classes que trata toda a comunicação base, usando análise SOAP e XML. Embora você possa usar a biblioteca de classes para consumir diretamente serviços XML da Web, a ferramenta WSDL e as outras ferramentas contidas no SDK facilitam os esforços de desenvolvimento com o .NET Framework. Se você desenvolver e publicar seus próprios serviços XML da Web, o .NET Framework fornecerá um conjunto de classes compatíveis com todos os padrões de comunicação como SOAP, WSDL, e XML. Usar as classes permite que você enfoque na lógica do seu serviço, sem se preocupar com com a infra-estrutura de comunicação exigida pelo desenvolvimento de software distribuídos. Finalmente, como páginas Web Forms no ambiente gerenciado, seu serviço XML da Web será executado com a velocidade de linguagem de máquina nativa, usando a comunicação escalonável do IIS.
Visual C# Consolidado
415
Common Language Runtime O .NET Framework fornece um ambiente de tempo de execução chamado Common Language Runtime, que executa o código e fornece serviços que facilitam o processo de desenvolvimento.
Visão geral do Common Language Runtime Compiladores e ferramentas expõem as funcionalidades do runtime e permitem que você escreva código que se beneficia desse ambiente de execução gerenciado. Código que você desenvolve com um compilador de linguagem que visa o runtime é chamado código gerenciado; ele se beneficia de recursos como integração entre linguagens, tratamento de exceção entre linguagens, segurança aprimorada, suporte a versionamento e implantação, um modelo simplificado para interação entre componentes, depuração e serviços de perfil. Para ativar o runtime para fornecer serviços de código gerenciado, compiladores de linguagens devem emitir metadados que descrevem os tipos, membros, e referências em seu código. Os metadados são armazenados com o código; todo arquivo executável portável (PE) carregável do common language runtime contém metadados. O runtime usa metadados para localizar e carregar classes, organizar instâncias na memória, resolver invocações método, gerar código nativo, reforçar a segurança, e definir limites de contexto em tempo de execução. O runtime automaticamente trata de objetos de layout e gerencia referências a objetos, liberandoos quando eles não estão sendo usados. Objetos cujos tempos de vida são gerenciados dessa forma são chamados de dados gerenciados. A coleta de lixo elimina vazamentos de memória e alguns outros erros comuns de programação. Se seu código é gerenciado, você pode usar dados gerenciados, dados não gerenciados ou ambos no seu aplicativo .NET Framework. Devido ao fato de compiladores de linguagens fornecerem seus próprios tipos, como tipos primitivos, você não pode sempre saber (ou precisa saber) se seus dados estão sendo gerenciados. O Common Language Runtime torna fácil a criação de componentes e aplicativos cujos objetos interagem entre linguagens. Objetos escritos em diferentes linguagens podem se comunicar entre si, e seus comportamentos podem ser totalmente integrados. Por exemplo, você pode definir uma classe e, em seguida, usar uma linguagem diferente para derivar uma classe de sua classe original ou chamar um método na classe original. Você também pode passar uma instância de uma classe para um método de uma classe escrito em uma linguagem diferente. Essa integração entre linguagens é possível porque os compiladores de linguagens e ferramentas que miram o runtime usam um CTS (Common Type System) definido pelo runtime, e eles seguem as regras do runtime para definir novos tipos, como também para criação, uso, persistência e ligação de tipos. Como parte de seus metadados, todos os componentes gerenciados transportam informações sobre os componentes e recursos dos quais eles foram construídos. O runtime usa essas informações para garantir que o componente ou aplicativo tenha as versões especificadas de tudo o que precisa, o que torna seu código menos suscetível a quebra devido a alguma dependência não encontrada. Informações de registro e dados do estado não são mais armazenadas no registro onde eles podem ser difíceis para estabelecer e manter. Em vez disso, as informações sobre os tipos que você definir (e suas dependências) são armazenados com o código como metadados, fazendo com que as tarefas de replicação de componentes e remoção sejam muito menos complicadas. Compiladores de linguagens e ferramentas expõem as funcionalidades do runtime de maneira a serem úteis e intuitivas para desenvolvedores. Isso significa que alguns recursos do runtime devem ser mais notáveis em um ambiente que em outro. Como você experimenta o runtime depende de qual compiladores de linguagem ou ferramentas você usa. Por exemplo, se você for um desenvolvedor Visual Basic, você pode notar que com o Common Language Runtime, a
Visual C# Consolidado
416
linguagem Visual Basic tem mais recursos orientados a objetos do que antes. A seguir estão alguns benefícios do runtime: •
Melhorias de desempenho.
•
Capacidade de facilmente usar componentes desenvolvidos em outras linguagens.
•
Tipos extensíveis fornecidos por uma biblioteca de classes.
•
Novos recursos da linguagem como herança, interfaces e sobrecarga para programação orientada a objetos; suporte a segmentação livre explícita que permite criação de aplicativos de vários segmentos, escalonáveis; suporte a tratamento de exceção estruturada e atributos personalizados.
Se você usar o Microsoft® Visual C++® .NET, você pode escrever código gerenciado usando o Managed Extensions for C++, que fornece os benefícios de um ambiente de execução gerenciado como também o acesso a recursos poderosos e tipos de dados expressivos que você está familiarizado. Recursos de runtime adicionais incluem: •
Integração entre linguagens, especialmente herança entre linguagens.
•
Coleta de lixo que gerencia o tempo de vida de objeto sendo a contagem de referência desnecessária.
•
Objetos autodescritivos, que fazem uso da Interface Definition Language (IDL) desnecessariamente.
•
A capacidade de compilar uma vez e executar em qualquer CPU e sistema operacional que dê suporte ao runtime.
Você também pode escrever código gerenciado usando a linguagem C#, que fornece os seguintes benefícios: •
Design completamente orientado a objetos.
•
Segurança de tipos muito forte.
•
Boa combinação da simplicidade do Visual Basic e poder do C++.
•
Coleta de lixo.
•
Sintaxe e palavras-chave semelhante as do C e C++.
•
Uso do delegates em vez de ponteiros de função para aumento da segurança de tipos e segurança. Ponteiros de função estão disponíveis através do uso da palavra-chave unsafe do C# e a opção /unsafe do compilador C# (CSC.exe) para código não gerenciado e dados.
Gerenciamento automático de memória Gerenciamento automático de memória é um dos serviços que o Common Language Runtime fornece durante a Execução Gerenciada. O coletor de lixo do Common Language Runtime gerencia a alocação e liberação de memória para um aplicativo. Para desenvolvedores, isso significa que você não tem que escrever código para executar tarefas de gerenciamento de memória quando você desenvolver aplicativos gerenciados. Gerenciamento automático de memória pode eliminar problemas comuns, como esquecer de liberar um objeto e causar um vazamento de memória, ou tentar acessar a memória de um objeto que já tinha sido liberado. Esta seção descreve como o coletor de lixo aloca e libera memória. Alocando memória
Visual C# Consolidado
417
Quando você inicializa um novo processo, o tempo de execução reserva uma região contígua de espaço de endereço para o processo. Este espaço de endereço reservado é chamado de heap gerenciada. A heap gerenciada mantém um ponteiro para o endereço onde o próximo objeto da heap será alocado. Inicialmente, esse ponteiro é definido como Endereço básico da heap gerenciada. Todos os tipos de referência são alocados na heap gerenciada. Quando um aplicativo cria o primeiro tipo de referência, é alocada memória para o tipo no Endereço básico da heap gerenciada. Quando o aplicativo cria o próximo objeto, o coletor de lixo aloca memória para ele no espaço de endereço imediatamente após o primeiro objeto. Desde que exista espaço de endereço disponível, o coletor de lixo continua a alocar espaço para novos objetos dessa maneira. Alocar memória de heap gerenciada é mais rápido que a alocação de memória não gerenciada. Pelo fato de que o Runtime aloca memória para um objeto adicionando um valor a um ponteiro, ele é quase tão rápido quanto a alocação de memória da pilha (stack). Além disso, porque novos objetos que são alocados consecutivamente são armazenados contiguamente na heap gerenciada, um aplicativo pode acessar os objetos muito rapidamente. Liberando memória O mecanismo otimizado do coletor de lixo determina o melhor momento para executar uma coleta com base nas alocações sendo feitas. Quando o coletor de lixo executa uma coleta, ele libera a memória dos objetos que não estão sendo usados pelo aplicativo. Ele determina quais objetos não estão mais sendo usados pelo exame das raízes do aplicativo. Cada aplicativo tem um conjunto de raízes. Cada raiz refere-se a um objeto na heap gerenciada ou é definida como nula. Raízes do aplicativo incluem ponteiros para objetos globais e estáticos, variáveis locais e parâmetros de objetos de referência na pilha de um segmento, e registro da CPU. O coletor de lixo tem acesso à lista de raízes ativas mantidas pelo runtime e pelo Compilador Just-In-Time (JIT). Usando essa lista, ele examina as raízes do aplicativo, e no processo cria um gráfico que contém todos os objetos que possam ser alcançados a partir as raízes. Objetos que não estão no gráfico são inacessíveis a partir das raízes do aplicativo. O coletor de lixo considera como lixo os objetos inacessíveis e irá liberar a memória alocada para eles. Durante uma coleta, o coletor de lixo examina a heap gerenciada, procurando pelos blocos de espaço de endereço ocupados por objetos inacessíveis. Na medida em que ele descobre cada objeto inacessível, ele usa uma função de cópia de memória para compactar os objetos acessíveis na memória, liberando os blocos de espaços endereço alocados para objetos inacessíveis. Uma vez que a memória para dos objetos acessíveis tiver sido compactada, o coletor de lixo faz as correções de ponteiros necessárias raízes de forma que as raízes do aplicativo apontem para os objetos em seus novos locais. Ele também posiciona o ponteiro da heap gerenciadas após o último objeto acessível. Observe que memória é compactada somente se uma coleta descobre um número significativo de objetos inacessíveis. Se todos os objetos na heap gerenciada sobrevivem a uma coleta, não há necessidade de compactação de memória. Para melhorar o desempenho, o tempo de execução aloca memória para objetos grandes em uma heap separada. O coletor de lixo libera automaticamente. a memória para objetos grandes Entretanto, para evitar mover objetos grandes na memória, essa memória não é compactada. Gerações e Desempenho Para otimizar o desempenho do coletor de lixo, a heap gerenciada está dividida em três gerações: 0, 1, e 2. O algoritmo de coleta de lixo do tempo de execução é baseado em várias generalizações que indústria de software de computador tem descoberto serem verdadeiras por experiências com esquemas de coleta de lixo Primeiro, é mais rápido compactar a memória para uma parte da heap gerenciada do que para toda a memória gerenciada. Em segundo lugar, objetos mais recentes terão vidas úteis menores e objetos mais antigos terão vidas úteis mais longas. Por fim, objetos mais recentes tendem a ser relacionados entre si e acessados pelo aplicativo ao redor do mesmo tempo.
Visual C# Consolidado
418
O coletor de lixo do Runtime armazena novos objetos na geração 0. Objetos criados com antecedência no tempo de vida do aplicativo que sobrevivem a coletas são promovidos e armazenados em gerações 1 e 2. O processo de promoção do objeto é descrito posteriormente neste tópico. Porque é mais rápido compactar uma parte da heap gerenciada que a heap inteira, este esquema permite que o coletor de lixo libere a memória em uma geração específica em vez liberar a memória para toda a memória gerenciada a cada vez que ele executa uma coleta. Na verdade, o coletor de lixo executa uma coleta quando a geração 0 está cheia. Se um aplicativo tentar criar um novo objeto quando a geração 0 está cheia, o coletor de lixo descobre que não existe nenhum espaço de endereço restante na geração 0 para alocar para o objeto. O coletor de lixo executa uma coleta em uma tentativa de liberar espaço de endereço na geração 0 para o objeto. O coletor de lixo inicia examinando os objetos na geração 0 em vez de todos os objetos na heap gerenciada. Isso é a abordagem mais eficiente, porque novos objetos costumam ter tempos de vida curtos, e é esperado que muitos dos objetos na geração 0 não estejam mais em uso mais pelo aplicativo quando uma coleta é executada. Além disso, uma única coleta de geração 0 freqüentemente recupera memória suficiente para permitir ao aplicativo continuar criando novos objetos. Após o coletor de lixo executar uma coleta de geração 0, ele compacta a memória para os objetos acessíveis conforme explicado anteriormente neste tópico em Liberando memória. O coletor de lixo então promove esses objetos e considera esta parte da heap gerenciada como geração 1. Pelo fato de que objetos que sobrevivem a coletas costumam ter vidas úteis mais longas, faz sentido promovê-los para uma geração superior. Como resultado, o coletor de lixo não tem que reexaminar os objetos em gerações 1 e 2 sempre que ele executa uma coleta de geração 0. Após o coletor de lixo executar sua primeira coleta de geração 0 e promover os objetos acessíveis na geração 1, ele considera o resto da heap gerenciada como geração 0. Ele continua a alocar memória para novos objetos na geração 0 até que a geração 0 esteja cheia e que seja necessário executar outra coleta. Nesse ponto, o mecanismo de otimização do coletor de lixo determina se ele é necessário examinar os objetos em gerações mais antigas. Por exemplo, se uma coleta de geração 0 não recupera memória suficiente para o aplicativo concluir sua tentativa de criar um novo objeto de forma bem sucedida, o coletor de lixo pode executar uma coleta de geração 1, e depois de geração 0. Se isso não recuperar memória suficiente, o coletor de lixo pode executar uma coleta de gerações 2, 1, e 0. Após cada coleta, o coletor de lixo compacta os objetos acessíveis na geração 0 e promove-os para geração 1. Objetos na geração 1 que sobrevivem a coletas são elevados para geração 2. Como o coletor de lixo oferece suporte somente a três gerações, objetos na geração 2 que sobrevivem a uma coleta permanecem na geração 2 até que eles sejam determinados como inalcançáveis em uma coleta futura. Liberando Memória para Recursos não Gerenciados Para a maioria dos objetos que seu aplicativo cria, você pode confiar no coletor de lixo para executar automaticamente as tarefas de gerenciamento de memória necessárias. Entretanto, recursos não gerenciados requerem limpeza explícita. O tipo mais comum de recurso não gerenciado é um objeto que envolve um recurso do sistema operacional, como um identificador de arquivo, identificador de janela, ou conexão de rede. Embora o coletor de lixo seja capaz de controlar o tempo de vida de um objeto gerenciado que encapsula um recurso não gerenciado, ele não tem conhecimento específico sobre como limpar o recurso. Quando você criar um objeto que encapsula um recurso não gerenciado, é recomendado que você forneça o código necessário para limpar o recurso não gerenciado em um método Dispose público. Ao fornecer um método Dispose, você permite que usuários do seu objeto explicitamente liberem sua memória quando eles tiverem concluído com o objeto. Quando você usa um objeto que encapsula um recurso não gerenciado, você deve estar ciente do Dispose e chamá-lo conforme necessário. Para obter mais informações sobre limpeza de recursos não gerenciados e um exemplo de um padrão de design para implementar Dispose, consulte Coleta Lixo.
Visual C# Consolidado
419
CTS (Common Type System) O CTS (Common Type System) define como tipos são declarados, usados, e gerenciados no ambiente de tempo de execução, e também é uma parte importante do suporte do ambiente de tempo de execução para integração entre linguagens. O CTS executa as seguintes funções: •
Estabelece uma estrutura que ajuda a habilitar integração entre linguagens, segurança de tipos, e execução de código de alto desempenho.
•
Fornece um modelo orientado a objetos que oferece suporte à implementação completa de muitas linguagens de programação.
•
Define regras que as linguagens devem seguir, que ajudam a assegurar que objetos escritos em linguagens diferentes podem interagir entre si.
Visão Geral do CTS (Common Type System) Esta seção descreve conceitos e define termos que ajudarão a compreender e trabalhar com a implementação do CTS da sua linguagem. Classificação de Tipos O CTS fornece suporte a duas categorias gerais de tipos, cada um delas é posteriormente dividida em subcategorias: •
Tipos de valor Tipos de valor contêm diretamente seus dados. Instâncias de tipos de valor ou são alocadas na pilha ou são alocadas internamente em uma estrutura. Tipos de valor podem ser internos (implementados pelo ambiente de execução), definidos pelo usuário ou enumerações. Para obter uma lista dos tipos valor internos, consulte a Biblioteca de Classes do .NET Framework.
•
Tipos de referência Tipos de referência armazenam uma referência para o endereço de memória do valor e são alocados no heap. Tipos referência podem ser tipos autodescritivos, tipos ponteiro ou tipos de interface. O tipo de um tipo de referência pode ser determinado a partir dos valores de tipos autodescritivos. Tipos autodescritivos são posteriormente divididos em matrizes e tipos de classe. Os tipos de classe são classes definidas pelo usuário, tipos de valor convertidos e delegates.
Variáveis que são tipos de valor possuem sua própria cópia dos dados e, portanto, operações em uma variável não afetam outras variáveis. Variáveis que são tipos de referência podem referenciar o mesmo objeto e, portanto, operações em uma variável podem afetar o mesmo objeto referenciado por outra variável. Todos os tipos derivam do tipo base System.Object. O exemplo a seguir mostra a diferença entre tipos de referência e tipos de valor. C# using System; class Class1 { public int Value = 0; } class Test { static void Main() { int val1 = 0; int val2 = val1; val2 = 123; Class1 ref1 = new Class1(); Class1 ref2 = ref1; ref2.Value = 123; Console.WriteLine("Values: {0}, {1}", val1, val2); Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value); } }
A saída do programa é a seguinte.
Visual C# Consolidado
420
Values: 0, 123 Refs: 123, 123
O diagrama a seguir ilustra como esses tipos estão relacionados. Observe que instâncias de tipos podem ser simplesmente tipos de valor ou tipos autodescritivos, mesmo que haja subcategorias desses tipos. Classificação de tipos
Valores e objetos Valores são representações binárias de dados. Os tipos fornecem uma maneira de interpretar esses dados. Um tipo de valor é armazenado como uma representação binária dos dados do tipo. O valor de um tipo de referência é a localidade da seqüência de bits que representam os dados do tipo. Cada valor possui um tipo exato que define por completo a representação do valor e as operações que são definidas no valor. Valores de tipos autodescritivos são chamados objetos. Enquanto é sempre possível determinar o tipo exato de um objeto examinando seu valor, não é possível fazer o mesmo com o um tipo de valor ou tipo ponteiro. Um valor pode ter mais de um tipo. Um valor cujo tipo implementa uma interface é também um valor do tipo da interface. Da mesma forma, um valor cujo tipo deriva de um tipo base é também um valor desse tipo base. Tipos e Assemblys O ambiente de execução usa assemblys para localizar e carregar tipos. O manifesto do assembly contém as informações que o ambiente de execução usa para resolver todas as referências de tipo feitas dentro do escopo do assembly. Um nome de tipo no ambiente de execução possui duas partes lógicas: o nome do assembly e o nome do tipo dentro do assembly. Dois tipos com o mesmo nome, mas em assemblys diferentes, são definidos como dois tipos distintos.
Visual C# Consolidado
421
Assemblys fornecem consistência entre o escopo de nomes vistos pelo desenvolvedor e o escopo de nomes vistos pelo sistema em tempo de execução. Os desenvolvedores criam tipos no contexto de um assembly. O conteúdo do assembly que está sendo criando por um desenvolvedor estabelece o escopo de nomes que estará disponível em tempo de execução. Tipos e Namespaces No ponto de vista do ambiente de execução, um namespace é apenas um conjunto de nomes de tipo. Determinadas linguagens podem ter construções que ajudam os desenvolvedores a formar grupos lógicos de tipos, mas essas construções não são usadas pelo ambiente de execução ao vincular tipos. Assim, ambas as classes Object e String são parte do namespace System, mas o ambiente de execução reconhece apenas os nomes completos de cada tipo que são System.Object e System.String, respectivamente Você pode criar um único assembly que expõe tipos que parecem ter vindo de dois namespaces hierárquicos diferentes, como System.Collections e System.Windows.Forms. Você também pode criar dois assemblys que exportam tipos cujos nomes contenham MyDll.MyClass. Se você criar uma ferramenta para representar tipos em um assembly como pertencentes a um namespace hierárquico, a ferramenta deve enumerar os tipos em um assembly, ou em um grupo de assemblys, e analisar os nomes dos tipos a fim de derivar um relacionamento hierárquico.
Definições de Tipo Você define novos tipos a partir de tipos existentes. Tipos de valor interno, ponteiros, matrizes e delegados são definidos quando eles são usados e são referidos como tipos implícitos. Tipos podem ser aninhados; ou seja, um tipo pode ser um membro de outro tipo. Uma definição de tipo inclui: •
Qualquer atributo definido no tipo.
•
A visibilidade do tipo.
•
O nome do tipo.
•
O tipo base do tipo.
•
Qualquer interface implementada pelo tipo.
•
Definições para cada um dos membros do tipo.
Atributos Atributos fornecem metadados adicionais definidos pelo usuário. Atributos podem ser aplicados a praticamente qualquer elemento de linguagem — tipos, propriedades, métodos e assim por diante. Tipo de acessibilidade Todos os tipos têm um modificador de acessibilidade que rege sua acessibilidade a outros tipos. A tabela a seguir descreve a acessibilidade de tipo suportada pelo runtime. Acessibilidade
Descrição
Público
O tipo é acessível por todos os assemblies.
Visual C# Consolidado
422
Assembly
O tipo é acessível somente dentro do assembly.
A acessibilidade de um tipo aninhado depende do seu domínio de acessibilidade, que é determinado pelas acessibilidade declarada do membro e pelo domínio de acessibilidade do tipo imediatamente contido. Entretanto, o domínio de acessibilidade de um tipo aninhado não pode exceder o do tipo contido. O domínio de acessibilidade de um membro aninhado M declarado em um tipo T de um programa P é definido como segue (observando que M, por si só, pode ser um tipo): •
Se a acessibilidade declarada de M for public, o domínio de acessibilidade de M é o domínio de acessibilidade de T.
•
Se a acessibilidade declarada de M for protected internal, o domínio de acessibilidade de M é a interseção do domínio de acessibilidade de T com o do texto do programa de P, e o texto do programa de qualquer tipo derivado de T, declarado fora de P.
•
Se a acessibilidade declarada de M for protected, o domínio de acessibilidade de M é a interseção do domínio de acessibilidade de T com o texto do programa de T, e qualquer tipo derivado de T.
•
Se a acessibilidade declarada de M for internal, o domínio de acessibilidade de M é a interseção do domínio de acessibilidade de T com o texto de programa de P.
•
Se a acessibilidade declarada de M for private, o domínio de acessibilidade de M é o texto de programa de T.
Nomes de Tipos O CTS impõe apenas duas restrições de nomes: 1.
Todos os nomes são codificados como seqüências de caracteres Unicode (16 bits).
2.
Não são permitidos nomes que tenham um valor (16 bits) incorporado de 0x0000.
Todas as comparações são feitas em uma base byte-by-byte, e possuem, portanto, diferenciação de maiúsculas e minúsculas e são independentes de local Embora um tipo possa fazer referência a tipos de outros módulos e assemblies, um tipo é totalmente definido dentro de um módulo. Nomes de tipo precisam somente ser exclusivos em um assembly. Para identificar totalmente um tipo, o nome do tipo deve ser qualificado pelo assembly que contém a implementação do tipo. Para mais informações, consulte Especificando Nomes de Tipos Totalmente Qualificados. Tipos Base e Interfaces Um tipo pode herdar valores e comportamentos de outro tipo. O CTS não permite que tipos sejam herdados de mais de um tipo base. Um tipo pode implementar qualquer número de interfaces. Para implementar uma interface, um tipo deve implementar todos os membros virtuais da interface. Um método virtual pode ser implementado por um tipo derivado e pode ser chamado estática ou dinamicamente. Para obter mais informações sobre membros virtuais, consulte Membros de Tipos. Para obter mais informações sobre herança e interfaces, consulte Classes e Interfaces. Membros de Tipos
Visual C# Consolidado
423
O comportamento e estado de um tipo são definidos pelos membros do tipo: eventos, campos, tipos aninhados, métodos e propriedades. Para mais informações, consulte Membros de Tipos.
Membros de Tipos O ambiente de execução permite que você defina os membros do tipo: eventos, campos, tipos aninhados, métodos e propriedades. Cada membro tem uma assinatura. A tabela a seguir descreve os membros usados no .NET Framework. Membro
Descrição
Evento
Define um incidente ao qual pode-se responder e define métodos para inscrever em, cancelar a inscrição em e levantar um evento. Eventos são freqüentemente usados para informar outros tipos de alterações de estado.
Campo
Descreve e contém parte do estado do tipo. Campos podem ser de qualquer tipo suportado pelo ambiente de execução.
Tipo aninhado
Define um tipo dentro do escopo do tipo delimitador.
Método
Descreve as operações disponíveis no tipo. A assinatura do método especifica os tipos dos argumentos e o valor de retorno do método. O construtor é um tipo especial de método que cria novas instâncias de um tipo.
Propriedade Nomeia um valor ou um estado do tipo e define métodos para obter ou definir o valor da propriedade. Propriedades podem ser tipos primitivos, coleções de tipos primitivos, tipos definidos pelo usuário ou coleções de tipos definidos pelo usuário. Propriedades são freqüentemente usadas para manter a interface pública de um tipo, independente da representação real do tipo. Características de um Membro O CTS (Common Type System) permite que os membros possuam uma variedade de características, mas as linguagens não necessariamente suportam todas elas. A tabela a seguir descreve as características de um membro.
Característica
Pode ser aplicada a
Descrição
abstract
Métodos, propriedades e eventos
O tipo não fornece a implementação do método. Tipos que herdam métodos abstratos e tipos que implementam interfaces com métodos abstratos devem fornecer uma implementação para o método. A única exceção é quando o tipo derivado é um tipo abstrato. Todos os métodos abstratos são virtuais.
private, family, assembly, family e assembly, family ou assembly, ou public
Todos
Define a acessibilidade de um membro: private Acessível somente dentro do tipo do membro ou dentro de um tipo aninhado. family Acessível dentro do tipo do membro e dentro de um tipo derivado que herda do tipo do membro. assembly Acessível somente no assembly no qual o tipo é definido. family e assembly
Visual C# Consolidado
424
Acessíveis somente dentro de tipos que se cumprem tanto as restrições de acesso da característica family quanto da característica assembly. family ou assembly Acessíveis somente dentro de tipos que se cumprem as restrições de acesso da característica family ou as restrições da característica assembly. public Acessíveis dentro de qualquer tipo. final
Métodos, propriedades e eventos
Um método virtual não pode ser substituído em um tipo derivado.
initialize-only
Campos
O valor pode apenas ser inicializado, não pode ser gravado outro valor após a inicialização.
instance
Campos, métodos, propriedades e eventos
Se um membro não estiver marcada como static (C# e C++), Shared (Visual Basic), virtual. (C# e C++) ou Overridable (Visual Basic), ele é um membro da instância (não existe a palavra-chave instance). Haverá o mesmo número de cópias desses membros na memória e de objetos que os usam.
literal
Campos
O valor atribuído ao campo é um valor fixo, conhecido em tempo de compilação, de um tipo de valor interno. Às vezes, campos marcados como literal são chamados de constantes.
newslot ou override
Todos
Define como o membro interage com os membros herdados que possuem a mesma assinatura: newslot Oculta membros herdados que possuem a mesma assinatura. override Substitui a definição de um método virtual herdado. O padrão é newslot.
static
Campos, métodos, propriedades e eventos
O membro pertence ao tipo no qual está definido e não a uma instância particular do tipo. O membro existe mesmo que uma instância de tipo não tenha sido criada. Ele é compartilhado entre todas as instâncias do tipo.
virtual
Métodos, propriedades e eventos
O método pode ser implementado por um tipo derivado e pode ser chamado estaticamente ou dinamicamente. Se foi usada uma chamada dinâmica, o tipo da instância que fez a chamada em tempo de execução determina qual implementação do método deve ser chamada, e não o tipo conhecido em tempo de compilação. Para chamar um método virtual estaticamente, pode ser necessário converter a variável (usando o operador cast) para um tipo que usa a versão desejada do método.
Sobrecarga
Visual C# Consolidado
425
Cada membro de tipo tem uma assinatura única. A assinatura de um método consistem do nome do método e da lista de parâmetros (a ordem e tipos dos argumentos do método). Mais de um método com o mesmo nome pode ser definido em um tipo desde que as assinaturas sejam diferentes. Quando dois ou mais métodos com o mesmo nome são definidos, diz-se que o método está sobrecarregado. Listas de parâmetros podem ser qualificadas por restrições varargs, indicando que o método suporta uma lista de argumentos variável. Por exemplo, em System.Char, o método IsDigit está sobrecarregado. Um método recebe um Char e retorna um Boolean, outro método recebe um Int32 e uma String e retorna um Boolean Herança, Substituição e Membros Ocultos Um tipo derivado herda todos os membros do seu tipo base, ou seja, esses membros estão definidos no tipo derivado e disponíveis para o mesmo. O comportamento, ou qualidades, de membros herdados pode ser modificado de duas maneiras: •
Um tipo derivado pode ocultar um membro herdado definindo um novo membro com a mesma assinatura. Isso pode ser feito quando deseja-se tornar um membro público em privado ou para definir um novo comportamento para um método herdado que está marcado como final.
•
Um tipo derivado pode substituir um método virtual herdado. O novo método fornece uma nova definição do método original. Essa nova definição será chamada baseando-se no tipo do valor em tempo de execução, em vez de no tipo conhecido em tempo de compilação. Um método só pode substituir um método virtual se o método virtual não está marcado como final. O novo método está pelo menos tão acessível quanto o método virtual.
Tipos de valor no Common Type System A maioria das linguagens de programação fornecem tipos de dados internos, como inteiros e números de ponto flutuante que são copiados quando eles são passados como argumentos (ou seja, eles são passados pelo valor). No .NET Framework, esses são os chamados tipos de valor. O Runtime oferece suporte a dois tipos de tipos de valor: •
Tipos de valor interno O .NET Framework define Tipos de valor interno, como System.Int32 e System.Boolean, que correspondem e são idênticos aos tipos de dados primitivos usados por linguagens de programação.
•
Tipos de valor definidos pelo usuário A sua linguagem fornecerá maneiras para definir seus próprios tipos de valor, que derivam de System.ValueType ou System.Enum. Se você desejar definir um tipo representando um valor que seja pequeno, como um número complexo (usando dois números de ponto flutuante), você pode optar por defini-lo como um tipo de valor porque você pode passar por valor o tipo de valor com eficiência. Se você estiver definindo um tipo que seria mais eficientemente passado por referência, em vez disso, você deve defini-lo como uma classe .
Para obter informações específicas sobre enumarações, consulte Enumerações no Common Type System (CTS). Tipos de valor são armazenados tão eficientemente quanto tipos primitivos, mas você pode chamar métodos neles, incluindo os métodos virtuais definidos nas classes System.ValueType e System.Object, assim como quaisquer métodos definidos no próprio tipo de valor. Você pode criar instâncias de tipos de valor, passá-los como parâmetros, armazená-los como variáveis locais, ou armazená-los em um campo de outro tipo de valor ou objeto. Tipos valor não têm a sobrecarga associada com o armazenamento de uma instância de uma classe e eles não exigem construtores.
Visual C# Consolidado
426
Para cada tipo de valor, o tempo de execução fornece um tipo convertido (boxed) correspondente, que é uma classe que tem o mesmo estado e comportamento que o tipo de valor. Algumas linguagens exigem que você utilize sintaxe especial quando o tipo convertido (boxed) é necessário; outras usam automaticamente o tipo convertido (boxed) quando for necessário. Quando você define um tipo de valor, você está definindo o tipo convertido (boxed) e o tipo nãoconvertido (unboxed). Tipos de valor podem ter campos, propriedades e eventos. Eles também podem ter métodos estáticos e não-estáticos. Quando eles são convertidos (boxed), eles herdam os métodos virtuais de System.ValueType, e eles podem implementar zero ou mais interfaces. Tipos de valor são autenticados (sealed), o que significa que nenhum outro tipo pode ser derivado a partir deles. Entretanto, você pode definir métodos virtuais diretamente sobre o tipo de valor, e esses métodos podem ser chamados tanto no na forma convertida (boxed) quanto na nãoconvertida (unboxed) do tipo. Embora você não possa derivar outro tipo de um tipo de valor, você pode definir métodos virtuais em um tipo de valor quando você estiver usando uma linguagem em que for mais conveniente trabalhar com métodos virtuais do que com métodos não-virtuais ou estáticos. O exemplo a seguir mostra como construir um tipo de valor para números complexos. C# using System; // Value type definition for a complex number representation. public struct Complex { public double r, i; // Constructor. public Complex(double r, double i) { this.r = r; this.i = i; } // Returns one divided by the current value. public Complex Reciprocal { get { if (r == 0d && i == 0d) throw new DivideByZeroException(); double div = r*r + i*i; return new Complex(r/div, -i/div); } } // Conversion operators. public static explicit operator double(Complex a) { return a.r; } public static implicit operator Complex(double r) { return new Complex(r,0d); } // Basic unary operators. public static Complex operator + (Complex a) { return a; } public static Complex operator - (Complex a) { return new Complex(-a.r, -a.i); } // Basic binary operators for addition, subtraction, multiplication, and division. public static Complex operator + (Complex a, Complex b) { return new Complex(a.r + b.r, a.i + b.i); } public static Complex operator (Complex a, Complex b) { return new Complex(a.r - b.r, a.i - b.i); } public static Complex operator * (Complex a, Complex b) { return new Complex(a.r*b.r - a.i*b.i, a.r*b.i + a.i*b.r); } public static Complex operator / (Complex a, Complex b) { return a * b.Reciprocal; } // Override the ToString method so the value appears in write statements. public override string ToString() { return String.Format("({0}+{1}i)", r, i); } } // Entry point. public class ValueTypeSample { public static void Main() { Complex a = new Complex(0, 1); Complex b = new Complex(0, -2); Console.WriteLine(); Console.WriteLine("a = " + a); Console.WriteLine("b = " + b); Console.WriteLine(); Console.WriteLine("a + b = " + (a+b)); Console.WriteLine("a - b = " + (a-b)); Console.WriteLine("a * b = " + (a*b)); Console.WriteLine("a / b = " + (a/b)); Console.WriteLine(); Console.WriteLine("(double)a = " + (double)a); Console.WriteLine("(Complex)5 = " + (Complex)5); } }
A saída deste programa é como se segue. a = (0+1i) b = (0+-2i) a + b = (0+-1i) a - b = (0+3i) a * b = (2+0i) a / b = (-0.5+0i) (double)a = 0 (Complex)5 = (5+0i)
Classes no Common Type System Se você estiver familiarizado com programação orientada a objetos, você sabe que uma classe define as operações que um objeto pode executar (métodos, eventos, ou propriedades) e define um valor que contém o estado do objeto (campos). Embora uma classe geralmente inclua tanto a
Visual C# Consolidado
427
definição quanto a implementação, ela pode ter um ou mais membros que não possuem implementação. Uma instância de uma classe é um objeto. Você acessa as funcionalidades de um objeto chamando seus métodos e acessando suas propriedades, eventos, e campos. A tabela a seguir fornece uma descrição de algumas das características que o tempo de execução permite para uma classe. (Características adicionais que estão disponíveis através de classes de Atributos não são incluídas nesta lista.) Sua linguagem pode não tornar todas essas características disponíveis. Característica
Descrição
autenticada
Especifica que outro tipo não pode ser derivado desse tipo.
implementa
Indica que a classe usa uma ou mais interfaces, fornecendo implementações de membros da interface.
Abstrata
Especifica que você não pode criar uma instância da classe. Para usá-la, você deve derivar outra classe a partir dela.
Herda
Indica que as instâncias da classe podem ser usadas em qualquer lugar em que a classe base for especificada. Uma classe derivada que herda de uma classe base pode usar a implementação de qualquer método virtual fornecido pela classe base, ou a classe derivada pode substituí-los com sua própria implementação.
exportada ou não Indica se uma classe está visível fora do Assembly em que ela está definida. exportada Só se aplica a classes de alto nível. Classes aninhadas também têm características membros. Para mais informações, consulte Tipos membros. Membros da classe que não têm implementação são membros abstratos. Uma classe que tenha um ou mais membros abstratos é ela própria abstrata; não é possível criar novas instâncias dessa classe. Algumas linguagens que direcionam o tempo de execução permitem que você marque uma classe como abstrata mesmo que nenhum de seus membros seja abstrato. Você pode usar uma classe abstrata quando você precisar encapsular um conjunto básico de funcionalidades que as classes derivadas podem herdar ou substituir quando for apropriado. Classes que não são abstratas são chamadas de classes concretas. Uma classe pode implementar qualquer número de interfaces, mas ela pode herdar apenas da uma classe base. Todas as classes devem ter pelo menos um construtor, que inicializa novas ocorrências da classe. Cada linguagem com suporte ao tempo de execução fornece uma maneira para indicar que uma classe ou membros da classe tem características específicas. Quando você usa a sintaxe exigida pela sua linguagem, a linguagem garante que as características da classe e seus membros são armazenados (como Metadados) junto com a implementação da classe.
Delegados no Common Type System O Runtime oferece suporte a tipos de referência, chamados delegados, que servem a um propósito semelhante ao de ponteiros de função em C++. Diferentemente de ponteiros de função, delegados são seguros, verificáveis e do tipo seguro. Um tipo delegado pode representar qualquer método com uma assinatura compatível. Enquanto ponteiros de função podem representar
Visual C# Consolidado
428
somente funções estáticas, um delegado pode representar métodos estáticos e de instâncias. Delegados são usados para manipular eventos e funções callback no .NET Framework. Todos os delegados são herdados do MulticastDelegate, que são herdados do Delegate. As linguagens C#, Visual Basic e C++ não permitem a herança desses tipos, ao invés de fornecerem palavras-chave para declarar delegados. Como representantes são herdados do MulticastDelegate, um delegado tem uma lista de invocação, que é uma lista dos métodos que o delegado representa, e que são executados quando o delegado é chamado. Todos os métodos da lista recebem os argumentos fornecidos quando o delegado é chamado. Observação O valor de retorno não está definido para um delegado que tenha mais de um método na sua lista de invocação, mesmo que o delegado tenha um tipo de retorno. Criando e usando representantes Em muitos casos, como em métodos callback, um delegado representa apenas um método, e as únicas ações você precisa fazer são criar e invocar o delegado. Para delegados que representam vários métodos, o .NET Framework fornece métodos de classes de delegação Delegate. e MulticastDelegate para dar suporte a operações como adicionar um método para a lista de invocação do um delegado (método System.Delegate.Combine(System.Delegate[])), remover um método (método System.Delegate.Remove(System.Delegate,System.Delegate)) e obter a lista de invocação (método System.Delegate.GetInvocationList) Observação Não é necessário usar esses métodos para delegados manipuladores de eventos no C#, C++ e Visual Basic, já que essas linguagens fornecem sintaxe para adicionar e remover manipuladores de eventos. Delegados Estáticos Fechados e Instâncias de Abertura de Delegados Delegados podem representar static (Shared no Visual Basic) ou métodos de instância. Normalmente quando um delegado representa um método de instância, a instância é acoplada ao delegado juntamente com o método. Por exemplo, um delegado manipulador de eventos pode ter três métodos de instância em sua lista de invocação, cada um com uma referência ao objeto ao qual o método pertence. Na versão 2.0 do .NET Framework, também é possível criar e abrir um delegado para um método de instância. Um método de instância tem um parâmetro da instância implícito (representado por this no C# ou Me no Visual Basic), e ele também pode ser representado por um tipo delegado que expõe este parâmetro oculto. Ou seja, o tipo delegado deve ter um parâmetro extra no início da sua lista formal de parâmetros, do mesmo tipo da classe a qual o método pertence. É oferecido suporte para o inverso desse cenário, para que seja possível vincular o primeiro argumento de um método estático.
Visual C# Consolidado
429
Observação
A criação de instância aberta e delegados estáticos fechados não possui suporte diretamente pelo Visual Basic, C++ ou C#, para construtores de delegados. Em vez disso, use um dos métodos de sobrecarga System.Delegate.CreateDelegate que especifica objetos MethodInfo, como System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo,System.Boole Regras relaxadas para vinculação de delegados Na versão 2.0 do .NET Framework, os tipos de parâmetro e retorno de um delegado devem ser compatíveis com os tipos de parâmetro e retorno do método que o delegado representa; os tipos não precisam coincidir exatamente. Observação Nas versões 1.0 e 1.1 do .NET Framework, os tipos devem coincidir exatamente. Um parâmetro de um delegado é compatível com o parâmetro correspondente de um método se o tipo do parâmetro do delegado for mais restritivo do que o tipo de parâmetro do método, porque isso garante que um argumento passado para o delegado possa ser passado com segurança para o método. Da mesma forma, o tipo de retorno de um delegado é compatível com o tipo de retorno de um método se o tipo de retorno do método for mais restritivo do que o tipo de retorno do delegado, porque isso garante que o valor de retorno do método possa ser difundido com segurança para o tipo retorno do delegado. Por exemplo, um delegado com um parâmetro do tipo Hashtable e um tipo de retorno de Object pode representar um método com um parâmetro de tipo Object e um valor de retorno do tipo Hashtable. Para obter mais informações e códigos de exemplo, consulte System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo). Representantes e chamadas assíncrona a método Cada delegado tem um método BeginInvoke que permite a você chamar o delegado assincronamente, e um método EndInvoke que limpa, posteriormente, os recursos. Esses métodos são gerados automaticamente para cada tipo delegado. Quando um delegado é chamado usando o método BeginInvoke, o método que o delegado representa é executado em um segmento pertencente ao do ThreadPool. Para obter mais informações e códigos de exemplo, consulte Programação assíncrona usando delegados.
Matrizes em Common Type System Um tipo matriz é definido especificando o tipo da matriz, a ordem (número de dimensões) da matriz e os limites superiores e inferiores de cada dimensão da matriz. Todos esses estão incluídos em qualquer assinatura de um tipo matriz, embora eles possam ser marcados como fornecidos dinamicamente (ao invés de estáticos). Tipos exatos de matriz são criados automaticamente pelo Runtime conforme eles são necessários, e nenhuma definição separada do
Visual C# Consolidado
430
tipo matriz é necessária. Matrizes de um determinado tipo só podem ter elementos desse tipo. Para obter mais informações sobre o tipo de um valor, consulte Valores e Objetos. Valores de um tipo matriz são objetos. Objetos de matrizes são definidos como uma série de locais onde valores do tipo elemento de matriz são armazenados. O número de valores repetidos é determinado pelo posto e limites da matriz. Tipos matriz são herdados do tipo System.Array. Esta classe representa todas as matrizes independentemente do tipo de seus elementos ou sua posição. As operações definidas em matrizes são: alocação de matriz baseada no tamanho e na informação de limite inferior; indexação de uma matriz para ler e escrever um valor; computação do endereço de um elemento da matriz (ponteiro gerenciado) e consulta da ordem, limites e número total de valores armazenados na matriz. Matrizes com uma dimensão de limite inferior para seus elementos (às vezes chamado vetores) igual a zero possui um tipo com base no tipo dos elementos da matriz, independentemente do limite superior. Matrizes com mais de uma dimensão, ou com uma dimensão porém com limite inferior diferente de zero, possuem o mesmo tipo se eles possuem o mesmo tipo de elemento e ordem, independentemente do limite inferior da matriz. Não há suporte para matrizes com dimensões zero.
Interfaces no Common Type System Interfaces podem ter membros estáticos, tipos aninhados, membros virtuais, propriedades e eventos. Qualquer classe que implementar uma interface deve fornecer definições para os membros abstratos declarados na interface. Uma interface pode exigir que qualquer classe de implementação também deve implementar uma ou mais interfaces. As restrições a seguir se aplicam a interfaces: •
Uma interface pode ser declarada com qualquer acessibilidade, mas todos membros de interface devem ter acessibilidade pública.
•
Nenhuma permissão de segurança pode ser anexada a membros ou à própria interface.
•
Interfaces não podem definir construtores.
Cada linguagem deve fornecer regras para mapear uma implementação para a interface que requer o membro, de maneira que mais de uma interface possa declarar um membro com a mesma assinatura e esses membros possam ter implementações separadas.
Ponteiros no Common Type System (CTS) Ponteiros são tipos especiais de variáveis. Há três tipos de ponteiros para os quais o ambiente de tempo de execução oferece suporte: ponteiros gerenciados, ponteiros não gerenciados e ponteiros de funções não gerenciados. Um ponteiro gerenciado, também conhecido como um identificador para um objeto no heap gerenciado, é um novo tipo de ponteiro disponível para aplicativos gerenciados. Ponteiros gerenciados são referências a um bloco gerenciado de memória no heap do Common Language Runtime. Coleta de lixo automática é executada neste heap. Ponteiros gerenciados são gerados para argumentos de métodos que são passados por referência. Algumas linguagens fornecem outras maneiras de gerar ponteiros gerenciados. Apenas os ponteiros gerenciados são compatíveis com CLS.
Visual C# Consolidado
431
Observação No Visual C++ 2002 e no Visual C++ 2003, __gc * foi usado para declarar um ponteiro gerenciado. Este será substituído por um ^ no Visual C++ 2005, por exemplo ArrayList^ al = gcnew ArrayList();. Um ponteiro não gerenciado é o tradicional ponteiro C++ para um bloco de memória não gerenciado do heap C++ padrão. Como ponteiros não gerenciados não fazem parte do CLS (Common Language Specification), sua linguagem pode não fornecer sintaxe para definir ou acessar estes tipos. Consulte a documentação da sua linguagem para informações sobre suporte a ponteiros não gerenciados. Um ponteiro de função não gerenciado é também um ponteiro C++ tradicional referente ao endereço de uma função. O CLS fornece os delegados como uma alternativa gerenciada para ponteiros de funções não gerenciados. Uma definição explícita de um tipo ponteiro não é necessária. Todas as informações necessárias para determinar o tipo de um ponteiro estão presentes quando o ponteiro é declarado. Enquanto tipos ponteiro são tipos de referência, o valor de um tipo ponteiro não é um objeto e você não pode determinar o tipo exato de tal valor. O CTS fornece duas operações com segurança de tipos em tipos ponteiro: carregar um valor e gravar um valor para o local referenciado pelo ponteiro. Estas operações com segurança de tipos são compatíveis com CLS. O CTS (Common Type System) também fornece três operações aritméticas de endereços baseadas em bytes para tipos ponteiro: adição e subtração de inteiros a ponteiros, e subtrair um ponteiro de outro. Os resultados das duas primeiras operações aritméticas retornam um valor do mesmo tipo que o ponteiro original. Estas operações baseadas em bytes não são compatíveis com CLS.
Visual C# Consolidado
432
Os metadados e os componentes autodescritivos No passado, um componente de software (.exe ou .dll) escrito em uma linguagem não podia facilmente usar um componente de software escrito em outra linguagem. COM foi um passo para a solução desse problema. O .NET Framework facilita a interoperação entre componentes permitindo que compiladores emitam informações declarativas adicionais em todos os módulos e assemblies. Essa informação, chamada de metadados, ajuda os componentes a interagir perfeitamente.
Visão Geral Sobre Metadados Metadados são informações binárias que descrevem o seu programa, o qual é fornecido em um arquivo PE do Common Language Runtime ou na memória. Quando você compila seu código em um arquivo PE, os metadados são inseridos em uma parte do arquivo, enquanto o código é convertido para a Microsoft Intermediate Language (MSIL) e inserido em outra parte do arquivo. Cada tipo e membro definido e referenciado em um módulo ou assembly é descrito em metadados. Quando o código é executado, o Runtime carrega os metadados na memória e os referencia para descobrir informações sobre suas classes de código, membros, herança e assim por diante. Os metadados descrevem cada tipo e membro definido no seu código de uma maneira neutra de linguagem. Os metadados armazenam as seguintes informações: •
Permissões de segurança necessárias para executar.
•
Descrição dos tipos.
o
Nome, visibilidade, classe base e interfaces implementadas.
o
Membros (métodos, campos, propriedades, eventos, tipos aninhados).
• o
Atributos. Elementos descritivos adicionais que modificam tipos e membros.
Benefícios de Metadados Os metadados são a chave para um modelo de programação simples, eliminando a necessidade de arquivos de Interface Definition Language (IDL), arquivos de cabeçalho ou qualquer método externo de referência a componente. Os metadados permitem que linguagens .NET se descrevam automaticamente de uma maneira neutra com relação a linguagem, sem que o desenvolvedor e o usuário vejam. Além disso, metadados são extensíveis pelo uso de atributos. Os metadados oferecem os seguintes benefícios principais: •
Arquivos autodescritivos. Módulos Common Language Runtime e assemblies são autodescritivos. Os metadados de um módulo contêm tudo o que ele precisa para interagir com outro módulo. Os metadados fornecem automaticamente a funcionalidade de IDL no COM, permitindo que você use um arquivo para definição e implementação. Módulos Runtime e assemblies não exigem registro com o sistema operacional. Como resultado, as descrições usadas pelo Runtime sempre refletem o código real no arquivo compilado, o que aumenta a confiabilidade do aplicativo.
•
Interoperabilidade de linguagem e facilidade de design baseado em componentes.
Visual C# Consolidado
433
Os metadados fornecem todas as informações necessárias sobre código compilado, para você herdar uma classe de um arquivo de escrita PE em uma linguagem diferente. Você pode criar uma instância de qualquer classe escrita em qualquer linguagem gerenciada (qualquer linguagem que atinge o Common Language Runtime), sem se preocupar com o empacotamento explícito ou com o uso de código de interoperabilidade personalizados. •
Atributos. O .NET Framework permite que você declare tipos específicos de metadados, chamados atributos, no seu arquivo compilado. Os atributos podem ser encontradas em toda a .NET Framework, e são usados para controlar mais detalhadamente como o seu programa se comporta em tempo de execução. Além disso, você pode emitir seus próprios metadados personalizados em arquivos do .NET Framework, através de atributos definidos pelo usuário. Para mais informações, consulte Estendendo Metadados Usando Atributos.
Estrutura e uso de metadados Embora a maioria dos desenvolvedores não necessitem saber os detalhes da implementação de metadados, alguns podem querer uma compreensão mais profunda. Esta seção fornece uma visão geral sobre como metadados são armazenados em um arquivo executável portátil (pe) do .NET Framework e uma explicação sobre a função dos metadados em execução gerenciadas. Você não precisa para ler esta seção para entender a programação .NET ou como usar atributos.
Metadados e Estrutura do Arquivos PE Os metadados são armazenadas em uma seção de um arquivo executável portável (PE) do .NET Framework, enquanto que a Microsoft Intermediate Language (MSIL) é armazenada em outra seção do arquivo PE. A parte de metadados do arquivo contém uma série de tabelas e estruturas de dados heap. A parte MSIL contém símbolos MSIL e de metadados que fazem referência a parte de metadados do arquivo PE. Você pode encontrar símbolos de metadados ao usar ferramentas como o Desassemblador do MSIL (Ildasm.exe) para exibir o MSIL do seu código ou o Depurador do Ambiente de Execução (Cordbg.exe) para executar um despejo de memória. Tabelas e Heaps de Metadados Cada tabela de metadados contém informações sobre os elementos do seu programa. Por exemplo, uma tabela de metadados descreve as classes em seu código, outra descreve os campos, e assim por diante. Se existirem dez classes em seu código, a tabela de classes terá dez linhas, uma para cada classe. Tabelas de metadados referenciam outras tabelas e heaps. Por exemplo, a tabela de metadados de classes faz referência a tabela de métodos. Metadados também armazenam informações em quatro estruturas de heap: string, BLOB, string de usuário e GUID. Todas as strings usadas para nomear tipos e membros são armazenadas no heap de strings. Por exemplo, uma tabela de métodos não armazena diretamente o nome de um método específico, mas aponta para nome do método armazenado no heap de strings. Símbolos de Metadados Cada linha de cada tabela de metadados é unicamente identificada na parte MSIL do arquivo PE por um símbolo de metadados. Símbolos de metadados são conceitualmente semelhantes a ponteiros, persistentes na MSIL, e referenciam uma tabela de metadados específica. Um símbolo de metadados é um número de quatro bytes. O byte superior denota a tabela de metadados, a qual se refere um token específico (método, tipo, e assim por diante). Os três bytes restantes especificam a linha na tabela de metadados que corresponde ao elemento de
Visual C# Consolidado
434
programação sendo descrito. Se você definir um método em C# e compilá-lo em um arquivo PE, o seguinte símbolo de metadados pode ser gerado na parte MSIL do arquivo PE: 0x06000004
O byte superior (0x06) indica que esse é um token MethodDef. Os três bytes inferiores (000004) informam ao Common Language Runtime para procurar na quarta linha da tabela MethodDef pelas informações que descrevem essa definição de método. Metadados em um arquivo PE Quando um programa é compilado para o Common Language Runtime, ele é convertido em um arquivo PE que consiste de três partes. A tabela a seguir descreve o conteúdo de cada parte. Seção do arquivo PE
Conteúdo da seção
Cabeçalho
O índice das seções principais do arquivo PE e o endereço do ponto de entrada. O ambiente de execução usa essas informações para identificar o arquivo como um arquivo PE e para determinar onde se iniciada a execução ao carregar o programa na memória.
Instruções da MSIL
As instruções da Microsoft Intermediate Language (MSIL) que compõem o seu código. Muitas instruções da MSIL são acompanhadas de símbolos de metadados.
Metadados
Tabelas e heaps de metadados. O ambiente de execução usa essa seção para registrar as informações sobre cada tipo e cada membro em seu código. Essa seção também inclui atributos personalizados e informações de segurança.
Uso de metadados em tempo de execução Para compreender melhor os metadados e sua função no Common Language Runtime, pode ser útil criar um programa simples e ilustrar como os metadados afetam sua própria vida em tempo de execução. O exemplo de código a seguir mostra dois métodos dentro uma classe chamada MyApp. O método Main é o ponto de entrada do programa, enquanto o método Add simplesmente retorna a soma dos dois argumentos inteiros. C# using System; public class MyApp { public static int Main() { int ValueOne = 10; int ValueTwo = 20; Console.WriteLine("The Value is: {0}", Add(ValueOne, ValueTwo)); return 0; } public static int Add(int One, int Two) { return (One + Two); } }
Quando o código é executado, o ambiente de execução carrega o módulo na memória e consulta os metadados para esta classe. Após carregado, o ambiente de execução executa uma ampla análise do fluxo Microsoft Intermediate Language (MSIL) do método para convertê-lo em instruções de máquina nativas rápidas. ambiente de tempo de execução usa um compilador JustIn-Time (JIT) para converter as instruções MSIL para código de máquina nativo para um método ao mesmo tempo conforme o necessário. O exemplo a seguir mostra parte do MSIL produzido a partir da função Main do código anterior. Você pode visualizar o MSIL e os metadados de qualquer aplicativo .NET Framework usando o Desassemblador do MSIL (ILDASM.exe).
O compilador JIT lê o MSIL para o método inteiro, analisa-o completamente, e gera instruções nativas eficientes para o método. Em IL_000d, um token de metadados para o método Add (/* 06000003 */) é encontrado e o ambiente de tempo de execução usa o token para consultar a terceira linha da tabela MethodDef. A tabela a seguir mostra parte da tabela MethodDef referenciada pelo token de metadados que descreve o método Add. Enquanto outras tabelas de metadados existirem neste assembly e tiverem seus próprios valores exclusivos, somente esta tabela é examinada. Endereço virtual relativo Linha (RVA)
ImplFlags Sinalizadores
Nome (Aponta para Assinatura o heap de seqüência (Aponta para o de caracteres.) heap de blob.)
1
0x00002050
IL Managed
Public .ctor (construtor) ReuseSlot SpecialName RTSpecialName .ctor
2
0x00002058
IL Managed
Public Static ReuseSlot
Main
String
3
0x0000208c
IL Managed
Public Static ReuseSlot
Add
int, int, int
Cada coluna da tabela contém informações importantes sobre seu código. A coluna RVA permite que o ambiente de tempo de execução calcule o endereço de memória inicial do MSIL que define este método. As colunas ImplFlags e Sinalizadores contêm máscaras de bits que descrevem o método (por exemplo, se o método é público ou privado). A coluna Nome indexa o nome do método a partir do heap de seqüência de caracteres. A coluna Assinatura indexa a definição da assinatura do método no heap de blob. O ambiente de tempo de execução calcula o endereço de deslocamento desejado a partir da coluna RVA na terceira linha e retorna este endereço para o compilador JIT, que depois passa para o novo endereço. O compilador JIT continua a processar o MSIL no novo endereço até encontrar outro token de metadados, e o processo é repetido. Usando metadados, o ambiente de tempo de execução tem acesso a todas as informações necessárias para carregar seu código e processá-lo em instruções de máquina nativas. Desta maneira, os metadados permitem arquivos autodescritivos e, juntamente com o CTS, herança entre linguagens.
Assemblies no Common Language Runtime Assemblies são os blocos de construção de aplicativos .NET Framework; eles formam a unidade fundamental de implantação, controle de versão, reutilização, ativação de escopo e permissões de segurança. Um assembly é uma coleção de tipos e recursos, que são construídos para trabalhar juntos e formam uma unidade lógica de funcionalidade. Um assembly fornece o Common
Visual C# Consolidado
436
Language Runtime com as informações necessárias para estar ciente das implementações de tipo. Para o Runtime, um tipo não existe fora o contexto de um assembly.
Visão Geral Sobre Assemblies Assemblies são uma parte fundamental da programação com o .NET Framework. Um assembly executa as seguintes funções: •
Ele contém código que o Common Language Runtime executa. O código Microsoft Intermediate Language (MSIL), em um arquivo executável portável (PE), não será executado se ele não possuir um manifesto do assembly associado. Observe que cada assembly pode ter somente um ponto de entrada (isto é, DllMain, WinMain ou Main).
•
Ele forma um limite de segurança. Um assembly é a unidade em que permissões são solicitadas e concedidas. Para obter mais informações sobre limites de segurança e como eles se aplicam a assemblies, consulte Considerações Sobre Segurança do Assembly.
•
Ele forma um limite de tipo. A identidade de cada tipo inclui o nome do assembly no qual ele reside. Um tipo chamado MyType, carregado no escopo de um assembly, não é o mesmo que um tipo chamado MyType, carregado no escopo de outro assembly.
•
Ele forma um limite de referência de escopo. O manifesto do assembly contém metadados do assembly que são usados para resolver tipos e satisfazer solicitações de recursos. Ele especifica os tipos e recursos que são expostos fora do assembly. O manifesto também enumera outros assemblies do qual ele depende.
•
Ele forma um limite de versão. O assembly é a menor unidade com controle de versão no Common Language Runtime; todos os tipos e recursos no mesmo assembly estão versionados como uma unidade. O manifesto do assembly descreve as dependências de versão que você especifica para qualquer assembly dependente. Para obter mais informações sobre o controle de versão, consulte Controle de Versão do Assembly.
•
Ele forma uma unidade de implantação. Quando um aplicativo é iniciado, somente os módulos assembly que o aplicativo chama inicialmente devem estar presente. Outros assemblies, como recursos de localização ou assemblies contendo classes utilitárias, podem ser recuperados por demanda. Isso permite que aplicativos sejam mantidos simples e pequenos no primeiro download. Para obter mais informações sobre como implantar assemblies, consulte Implantação de Aplicativos.
•
Essa é a unidade na qual a execução lado a lado é suportada. Para obter mais informações sobre como executar várias versões de um assembly, consulte Assemblies e Execução Lado a Lado.
Assemblies podem ser estáticos ou dinâmicos. Assemblies estáticos podem incluir tipos .NET Framework (interfaces e classes), bem como recursos para o assembly (bitmaps, arquivos JPEG, arquivos de recursos, e assim por diante). Assemblies estáticos são armazenados em disco em arquivos PE. Você também pode usar o .NET Framework para criar assemblies dinâmicos, que são executados diretamente da memória e não são salvos em disco antes da execução. Você pode salvar assemblies dinâmicos no disco após sua execução. Há várias maneiras de criar assemblies. Você pode usar ferramentas de desenvolvimento, como Visual Studio 2005, que você usou anteriormente para criar arquivos .dll ou .exe. Você pode usar ferramentas fornecidas pelo SDK do .NET Framework para criar assemblies, com módulos criados em outros ambientes de desenvolvimento. Você também pode usar APIs do Common Language Runtime, como Reflection.Emit, para criar assemblies dinâmicos.
Visual C# Consolidado
437
Benefícios do Assembly Assemblys são projetados para simplificar a implantação de aplicativos e para solucionar problemas de versionamento que podem ocorrer em aplicativos baseados em componentes. Usuários finais e desenvolvedores estão familiarizados com problemas de versionamento e implantação. Problemas esses que surgem nos atuais sistemas baseados em componentes. Alguns usuários finais têm sofrido a frustração de instalar um novo aplicativo em seus computadores apenas para descobrir que outro aplicativo existente simplesmente parou de funcionar. Muitos desenvolvedores já gastaram inúmeras horas tentando manter consistentes todas as entradas do registro necessárias para ativar uma classe COM. Muitos problemas de implantação têm sido resolvidos através uso de assemblys no .NET Framework. Por eles seres componentes autodescritivos e por não dependerem de entradas do registro, assemblys permitem que a instalação de aplicativos não tenha impacto algum. Eles também simplificam a desinstalação e duplicação de aplicativos. Problemas de Versionamento Atualmente, dois problemas de versionamento ocorrem em aplicativos Win32: •
Regras de versionamento não podem ser expressas entre partes de um aplicativo e impostas pelo sistema operacional. A abordagem atual depende da compatibilidade com versões anteriores, o que é geralmente difícil de garantir. Uma vez publicadas, as definições de interface devem ser estáticas. Uma única parte do código deve manter a compatibilidade com as versões anteriores. Além disso, o código deve ser desenvolvido de forma que somente uma única versão do mesmo possa estar presente e executando em um computador em qualquer instante de tempo.
•
Não há como manter a consistência entre conjuntos de componentes que são criados juntos e o conjunto que está presente em tempo de execução.
Esses dois problemas de versionamento combinados criam conflitos de DLL, onde a instalação de um aplicativo pode, inadvertidamente, quebrar um outro existente. Isso ocorre porque foi instalado um determinado componente de software, ou DLL, que não era totalmente compatível com as versões anteriores. Após decorrida essa situação, o sistema não possui suporte para diagnosticar e corrigir o problema. Acabando com os conflitos de DLL O Microsoft ® Windows ® 2000 começou a atacar por completo esses problemas. Ele fornece dois recursos que corrigem parcialmente conflitos de DLL: •
O Windows 2000 permite criar aplicativos cliente cujos arquivos .dll localizam-se na mesma pasta do executável do aplicativo. O Windows 2000 pode ser configurado para verificar um componente no diretório onde o executável está localizado antes de verificar o caminho totalmente qualificado ou procurar o caminho normal. Isso permite que componentes sejam independentes de componentes instalados e usados por outros aplicativos.
•
O Windows 2000 bloqueia arquivos que vêm com o sistema operacional no diretório System32, para que eles não possam ser substituídos quando novos aplicativos são instalados.
O Common Language Runtime usa assemblys para continuar essa evolução em direção de uma solução completa para conflitos de DLL. A Solução do Assembly
Visual C# Consolidado
438
Para resolver problemas de versionamento, assim como problemas restantes que levam a conflitos de DLL, o ambiente de execução usa assemblys a fim de: • • •
Permitir que os desenvolvedores especifiquem regras de versão entre diferentes componentes de software. Fornecer a infra-estrutura para impor regras de versão. Fornecer a infra-estrutura para permitir que várias versões de um componente sejam executadas simultaneamente (o que chamamos de execução lado a lado).
Consulte também
Sumário de assembly Em geral, um assembly estático pode consistir de quatro elementos: •
O manifesto do assembly, que contém metadados do assembly.
•
Metadados de tipo.
•
Código Microsoft Intermediate Language (MSIL) que implementa os tipos.
•
Um conjunto de recursos.
Somente o manifesto do assembly é obrigatório, mas tipos e recursos são ambos necessários para fornecer ao assembly qualquer funcionalidade significativa. Há várias maneiras de se agrupar esses elementos em um assembly. Você pode agrupar todos os elementos em um único arquivo físico, que é mostrado na ilustração a seguir. Assembly de arquivo único
Como alternativa, os elementos de um assembly podem estar contidos em vários arquivos. Esses arquivos podem ser módulos de código compilado (.netmodule), recursos (como arquivos .bmp ou .jpg), ou outros arquivos necessários para o aplicativo. Crie um assembly multi-arquivos quando desejar combinar módulos escritos em diferentes linguagens e otimizar o download de um aplicativo colocando tipos raramente usados em um módulo que é baixado apenas quando necessário. Na ilustração a seguir, o desenvolvedor de um aplicativo hipotético escolheu separar alguns códigos utilitários em um módulo diferente e manter um arquivo grande de recurso (neste caso uma imagem .bmp) em seu arquivo original. O .NET Framework baixa um arquivo somente quando ele é referenciado; manter códigos raramente referenciados em um arquivo separado do aplicativo otimiza o download de código. Assembly multi-arquivos
Visual C# Consolidado
439
Observação Os arquivos que compõem um assembly multi-arquivos não são fisicamente vinculados pelo sistema de arquivos. Em vez disso, eles são vinculados através do manifesto do assembly e o Common Language Runtime gerencia-os como uma unidade. Nesta ilustração, todos os três arquivos pertencem a um assembly, conforme descrito no manifesto do assembly contido em MyAssembly.dll. Para o sistema de arquivos, eles são três arquivos separados. Observe que o arquivo Util.netmodule foi compilado como um módulo porque ele não contém nenhuma informação de assembly. Quando o assembly foi criado, o manifesto do assembly foi adicionado ao MyAssembly.dll, indicando seu relacionamento com Util.netmodule e Graphic.bmp. Assim como você cria hoje seu código-fonte, você toma decisões sobre como particionar a funcionalidade do seu aplicativo em um ou mais arquivos. Ao criar código do .NET Framework, você tomará decisões semelhantes sobre como particionar a funcionalidade em um ou mais assemblies.
Manifesto do Assembly Cada assembly, seja estático ou dinâmico, contém uma coleção de dados que descrevem como os elementos do assembly se relacionam entre si. O manifesto do assembly contém esses metadados do assembly. O manifesto de um assembly contém todos os metadados necessários para especificar os requisitos de versão e o identificador de segurança, assim como todos os metadados necessários para definir o escopo do assembly e analisar referências a recursos e classes. O manifesto do assembly pode ser armazenado em um arquivo PE (.exe ou .dll) com código da Microsoft Intermediate Language (MSIL) ou em um arquivo PE autônomo que contém somente informações do manifesto do assembly. A ilustração a seguir mostra as diferentes maneiras nas quais o manifesto pode se armazenado. Tipos de assemblys
Visual C# Consolidado
440
Para um assembly com um arquivo associado, o manifesto é incorporado no arquivo PE para formar um assembly de arquivo único. Você pode criar um assembly de vários arquivos com um arquivo de manifesto autônomo ou com o manifesto incorporado a um dos arquivos PE do assembly. Cada manifesto de um assembly executa as seguintes funções: Enumerar os arquivos que compõem o assembly.
• •
Orientar como as referências a tipos e recursos do assembly são mapeadas em arquivos que contêm suas declarações e implementações. Enumerar outros assemblys dos quais depende o assembly.
• •
Fornecer um nível de indireção entre os consumidores do assembly e detalhes da implementação do assembly.
•
Processar o assembly autodescritivo.
Conteúdo do Manifesto do Assembly A tabela a seguir mostra as informações contidas no manifesto do assembly. Os primeiros quatro itens — informações sobre o nome, o número de versão, a cultura e o nome forte do assembly — compõem a identidade do assembly. Informações
Descrição
Nome do assembly Uma seqüência de texto especificando o nome do assembly. Número de versão
Um número de versão principal e secundário e um número de revisão e de compilação. O Common Language Runtime usa esses números para impor uma política de versões.
Cultura
Informações sobre a cultura ou a linguagem suportada pelo assembly. Essas informações devem ser usadas somente para designar um assembly como um assembly satélite contendo informações específicas de cultura ou de linguagem. (Um assembly com informações de cultura é automaticamente considerado um assembly satélite.)
Informações de nomes fortes
A chave pública do publisher, caso tenha sido dado ao assembly um nome forte.
Lista de todos os arquivos no assembly
Um hash de cada arquivo contido no assembly e um nome de arquivo. Observe que todos os arquivos que compõem o assembly devem estar no mesmo diretório que o arquivo que contém o manifesto do assembly.
Informações de
Informações usadas pelo ambiente de execução para mapear a referência
Visual C# Consolidado
441
referência de tipo
de um tipo ao arquivo que contém sua declaração e implementação. Usado para tipos que são exportados do assembly.
Informações sobre assemblys referenciados
Uma lista de outros assemblys que são referenciados estaticamente pelo assembly. Cada referência inclui o nome do assembly dependente, metadados do assembly (versão, cultura, sistema operacional, e assim por diante) e chave pública, caso o assembly possua um nome forte.
Você pode adicionar ou alterar informações do manifesto do assembly usando os atributos do assembly em seu código. Você pode alterar informações sobre versão e atributos informativos, incluindo Trademark (marca comercial), Copyright (direitos autorais), Product (produto), Company (empresa) e Informational Version (versão informativa). Para obter uma lista completa dos atributos de um assembly, consulte Definindo os Atributos de um Assembly.
Cache Global de Assemblies Cada computador onde o Common Language Runtime está instalado tem um cache de código da máquina chamado de Cache Global de Assemblies. O Cache Global de Assemblies armazena assemblies especificamente designados para serem compartilhados por vários aplicativos no computador. Você deve compartilhar assemblies instalando-os no cache global de assemblies somente quando você precisa fazê-lo. Como diretriz geral, mantenha as dependências de um assembly privadas, e localize assemblies no diretório de aplicativo a não ser que o compartilhamento de um Assembly seja explicitamente necessário. Além disso, não é necessário instalar assemblies no cache global de assemblies para torná-los acessíveis para interoperabilidade COM ou código não gerenciado. Observação Há situações em que você explicitamente não deseja instalar um Assembly no cache global de assemblies. Se você colocar um dos assemblies que compõem um aplicativo no cache global de assemblies, você não pode mais duplicar ou instalar o aplicativo usando o comando xcopy para copiar o diretório do aplicativo. Você também deve mover o assembly no cache global de assemblies. Há várias maneiras para implantar um Assembly no cache global de assemblies: •
Use um instalador desenvolvido para funcionar com o cache global de assemblies. Essa é a opção preferencial para instalar assemblies para o cache global de assemblies.
•
Use uma ferramenta de desenvolvimento chamada de ferramenta Global Assembly Cache (Gacutil.exe), fornecida pelo o .NET Framework SDK
•
Use o Windows Explorer para arrastar módulos assemblies para o cache. Observação Nos cenários de implantação, use o Windows Installer 2.0 (site em inglês) para instalar assemblies para o cache global de assemblies. Use o Windows Explorer ou a ferramenta Global Assembly Cache apenas em cenários de desenvolvimento, porque eles não fornecem contagem de referência do assembly e outros recursos fornecidos ao usar o Windows Installer.
Visual C# Consolidado
442
Os administradores geralmente protegem o diretório systemroot usando uma lista de controle de acesso (ACL) para controlar escrita e acesso de execução. Pelo fato de o cache global de assemblies estar instalado em um subdiretório do diretório systemroot, ele herda o ACL dessa pasta. É recomendável que apenas os usuários com privilégios de administrador tenham permissão para excluir arquivos do cache global de assemblies. Assemblies implantados no cache global de assemblies devem ter um nome forte. Quando um Assembly é adicionado ao cache global de assemblies, são executadas verificações de integridade em todos os arquivos que compõem o Assembly. O cache executa essas verificações de integridade para garantir que um Assembly não foi violada, por exemplo, quando um arquivo foi alterado mas o manifesto não refletir a alteração.
Assemblies de Nomes Fortes Um nome forte consiste na identidade assembly— seu nome de texto simples, número de versão, e informações de cultura (se fornecido) — mais uma chave pública e uma assinatura digital. Ela será gerada a partir de um arquivo Assembly (o arquivo que contém o manifesto do Assembly, que por sua vez contém os nomes e hashes de todos os arquivos que compõem o assembly), usando a chave particular correspondente. O Microsoft® Visual Studio® .NET e outras ferramentas de desenvolvimento fornecidas no .NET Framework SDK podem atribuir nomes fortes para um Assembly. É esperado que assemblies com o mesmo nome forte sejam idênticos. Você pode garantir que um nome seja globalmente exclusivo assinando um assembly com um nome forte. Especificamente, nomes fortes satisfazem os requisitos a seguir: •
Nomes Fortes garantem a exclusividade do nome por confiar em pares de chaves exclusivas. Ninguém pode gerar o mesmo nome de assembly que você pode, porque um Assembly gerado com uma chave particular tem um nome diferente que um Assembly gerado com outra chave particular.
•
Nomes Fortes protegem a linhagem da versão de um Assembly. Um nome forte pode garantir que ninguém pode produzir uma versão posterior do seu Assembly. Os usuários podem ter certeza que a versão do assembly que eles estão carregando vem do mesmo Publisher que criou a versão na qual o aplicativo foi compilado.
•
Nomes Fortes fornecem uma verificação de integridade forte. Passando as verificações de segurança do .NET Framework garante-se que o conteúdo do assembly não foi alterado desde que ele foi criado. Observe, entretanto, que nomes fortes dentro e por eles mesmos não implicam um nível de confiança como fornecido, por exemplo, por uma assinatura digital e suportando certificado.
Quando você referencia um assembly de nome forte, você espera obter certos benefícios, como versão e proteção de nomeação. Se o Assembly de nome forte então referencia um Assembly com um nome simples, que não tem esses benefícios, você perde as vantagens que iria derivar pelo uso de um Assembly de nome forte e reverte para conflitos de DLL. Por essa razão, assemblies de nomes fortes podem apenas referenciar outros assemblies de nomes fortes.
Considerações sobre segurança de assemblies •
Quando você cria um assembly, você pode especificar um conjunto de permissões que o assembly requer para executar. Se determinadas permissões são concedidas ou não a um assembly isso é baseado nas evidências.
Há duas formas distintas de evidências que são usadas:
Visual C# Consolidado
443
•
A evidência de entrada será mesclada com a evidência coletada pelo carregador para criar um conjunto final de evidências usadas para resolução de política. Os métodos que usam essa semântica incluem Assembly.Load, Assembly.LoadFrom e Activator.CreateInstance.
•
A evidência de entrada é usada inalterada como o conjunto final de evidências usado para resolução de política. Os métodos que usam essa semântica incluem AppDomain.DefineDynamicAssembly() e Assembly.Load(byte[]).
Permissões opcionais podem ser concedidas pelo conjunto de políticas de segurança no computador onde o assembly será executado. Se você desejar que seu código manipule todas as exceções de segurança potenciais, você pode seguir um desses procedimentos: •
Inserir uma solicitação de permissão para todas as permissões que seu código deve ter, e tratar a falha em tempo de carga que ocorre se as permissões não são concedidas.
•
Não usar uma solicitação de permissão para obter permissões que seu código pode não precisar, mas estar preparado para manipular exceções de segurança se as permissões não são concedidas. Observação Segurança é uma área complexa, e você tem várias opções para escolher. Para mais informações, consulte Conceitos chave sobre segurança.
Em tempo de carga, as evidências do assembly são usadas como entrada para políticas de segurança. A política de segurança é estabelecida pela empresa e pelo administrador do computador bem como por configurações de políticas de usuário e determina o conjunto de permissões que é concedido a todos os códigos gerenciados quando executados. Políticas de segurança podem ser estabelecidas para o publisher do assembly (se ele tiver uma assinatura gerada por uma ferramenta de assinatura), para o site e zona (em termos do Internet Explorer) de que o assembly foi baixado, ou para o nome forte do assembly. Por exemplo, um administrador pode estabelecer políticas de segurança que permitem que todo código baixado do site e assinado por uma determinada de empresa software acesse um banco de dados em um computador, mas não concede acesso para gravar no disco do computador. Assemblies de nome forte e ferramentas de assinatura Você pode assinar um assembly de duas maneiras diferentes mas complementares: com um nome forte ou usando a Ferramenta de Assinatura de Arquivo (Signcode.exe) no .NET Framework versão 1.0 e 1.1 ou a Ferramenta de Assinatura (SignTool.exe) em versões posteriores do .NET Framework. Assinar um assembly com um nome forte adiciona uma criptografia de chave pública ao arquivo que contém o manifesto do assembly. Assinatura de nome forte ajuda a verificar exclusividade de nome, a evitar falsificação de nome, e a fornecer chamadores com alguma identidade quando uma referência é resolvida. No entanto, nenhum nível de confiança é associado a um nome forte, o que torna a Ferramenta de Assinatura de Arquivo (Signcode.exe) e Ferramenta de Assinatura (SignTool.exe) importantes. As duas ferramentas de assinatura requerem um publisher para provar sua identidade para uma autoridade de terceiros e obter um certificado. Esse certificado é então incorporado no seu arquivo e pode ser usado por um administrador para decidir se confia na autenticidade do código. Você pode dar um nome forte e uma assinatura digital criada usando a Ferramenta de Assinatura de Arquivo (Signcode.exe) ou a Ferramenta de Assinatura (SignTool.exe) para um assembly, ou você pode usar um sozinho. As duas ferramentas de assinatura podem assinar somente um arquivo por vez; para um assembly com vários arquivos, você assina o arquivo que contém o manifesto do assembly. Um nome forte é armazenado no arquivo que contém o manifesto do
Visual C# Consolidado
444
assembly, mas uma assinatura criada usando a Ferramenta de Assinatura (SignTool.exe) ou a Ferramenta de Assinatura de Arquivo (Signcode.exe) é armazenada em um slot reservado no arquivo executável portável (PE) que contém o manifesto do assembly. A assinatura de um assembly usando a Ferramenta de Assinatura de Arquivo (Signcode.exe) ou a Ferramenta de Assinatura (SignTool.exe) pode ser usada (com ou sem um nome forte) quando você já tem uma hierarquia de confiança que confia nas assinaturas geradas pela Ferramenta de Assinatura de Arquivo (Signcode.exe) ou pela Ferramenta de Assinatura (SignTool.exe), ou quando sua política usa somente a parte chave e não verifica uma cadeia de confiança. Observação Ao usar um nome forte e uma assinatura gerada por uma ferramenta de assinatura em um assembly, o nome forte deve ser atribuído primeiro. O Common Language Runtime também executa uma verificação de hash; o manifesto do assembly contém uma lista de todos os arquivos que compõem o assembly, incluindo um hash de cada arquivo como ele existia quando o manifesto foi criado. Como cada arquivo é carregado, seu conteúdo é comparado com o valor de hash armazenado no manifesto. Se os dois hashes não coincidirem, o assembly falha ao carregar. Devido ao nome forte e à assinatura usarem a garantia de integridade da Ferramenta de Assinatura de Arquivo (Signcode.exe) ou da Ferramenta de Assinatura (SignTool.exe), você pode basear a política de segurança para acesso a código nessas duas formas de evidências do assembly. Nome forte e assinatura usam garantia de integridade da Ferramenta de Assinatura (SignTool.exe) ou da Ferramenta de Assinatura de Arquivo (Signcode.exe) através de assinaturas digitais e certificados. Todas as tecnologias mencionadas — Verificação de hash, nome forte, e assinatura usando a Ferramenta de Assinatura de Arquivo (Signcode.exe) ou a Ferramenta de Assinatura (SignTool.exe) — trabalham juntas para assegurar que o assembly não tenha sido alterado de nenhuma maneira.
Versionamento de Assembly Todos os versionamentos de assemblys que usam o Common Language Runtime são feitos no nível do assembly. A versão de um assembly e as versões de assemblys dependentes são registradas no manifesto do assembly. O política de versões padrão do ambiente de execução diz que aplicativos devem executar somente com as versões com que foram criados e testados, a menos que essa política de versões seja anulada por uma outra política explícitada nos arquivos de configuração (o arquivo de configuração do aplicativo, o arquivo de política de editor e o arquivo de configuração do administrador do computador). Observação Versionamento é feito somente em assemblys com nomes fortes. O ambiente de execução executa as seguintes etapas para resolver uma solicitação de ligação de assembly: 1. 2.
Verificar a referência do assembly original para determinar qual versão do assembly deve ser ligada. Verificar os arquivos de configuração apropriados para aplicar um política de versões.
Visual C# Consolidado
445
3.
Determinar o assembly correto a partir da referência do assembly original e de qualquer redirecionamento especificado nos arquivos de configuração. Determinar a versão que deve ser ligada ao assembly sendo chamado.
4.
Verifica a cache global de assemblys, bases de código especificadas em arquivos de configuração, e, em seguida, verifica os diretórios e subdiretórios do aplicativo usando as regras de probing explicadas em Como o Ambiente de Execução Localiza Assemblys.
A ilustração a seguir mostra essas etapas. Resolvendo uma solicitação de ligação de assembly
Para obter mais informações sobre como configurar aplicativos, consulte Arquivos de Configuração. Para obter mais informações sobre políticas de ligação, consulte Como o Ambiente de Execucão Localiza Assemblys. Informações de Versão Cada assembly possui duas maneiras diferentes de expressar informações de versão: •
Através do número de versão do assembly. Juntamente com as informações de nome e cultura do assembly, o número de versão é parte da identidade do assembly. Esse número é usado pelo ambiente de execução para impor uma política de versões e representa um papel importante no processo de resolução de tipo em tempo de execução.
•
Através de uma versão informativa, uma seqüência que representa informações de versão adicionais incluída apenas para fins informativos.
Número de Versão do Assembly Cada Assembly tem um número de versão como parte de sua identidade. Dessa forma, dois assemblys que diferem pelo número de versão são considerados pelo ambiente de execução assemblys completamente diferentes. Fisicamente, esse número de versão é representado através de uma seqüência dividida em quatro partes com o seguinte formato:
Visual C# Consolidado
446
< versão principal>... Por exemplo, a versão 1.5.1254.0 indica que 1 é a versão principal, 5 é a versão secundária, 1254 é o número de compilação e 0 é o número de revisão. O número de versão é armazenado no manifesto do assembly junto com outras informações de a identidade, incluindo o nome e a chave pública do assembly e informações de relacionamentos e identidades de outros assemblys conectados ao aplicativo. Quando um assembly é criado, a ferramenta de desenvolvimento registra as informações de dependência de cada assembly referenciado no manifesto do assembly. O ambiente de execução usa esses números versão, em conjunto com informações de configuração definidas por um administrador, por um aplicativo, ou por um publisher, a fim de carregar a versão apropriada de um assembly referenciado. O ambiente de execução distingue assemblys regulares de assemblys com nomes fortes para fins de versionamento. A verificação de versão só ocorre em assemblys com nomes fortes. Para obter informações sobre como especificar uma política de ligação de versão, consulte Arquivos de Configuração. Para obter informações sobre como o ambiente de execução usa informações de versão para localizar um Assembly específico, consulte Como o Ambiente de Execução Localiza Assemblys. Versão Informativa do Assembly A versão informativa é uma seqüência que anexa informações adicionais de versão a um assembly, apenas para fins informativos. Essas informações não são usadas em tempo de execução. A versão informativa baseada em texto corresponde a literatura de marketing do produto, a embalagem ou ao nome do produto e não é usada pelo ambiente de execução. Por exemplo, uma versão informativa poderia ser "Common Language Runtime versão 1.0" ou " NET Control SP 2 ". Na guia Version da caixa de diálogo File Properties do Microsoft Windows, essas informações aparecem no item "Product Version". Observação Embora você possa especificar qualquer texto, uma mensagem de aviso aparecerá durante a compilação em dois casos: (i) se a seqüência não possuir o formato usado pelo número de versão do assembly ou (ii) se está no formato correto, mas contém wildcards. Esse aviso é inofensivo. A versão informativa é representada usando o atributo System.Reflection.AssemblyInformationalVersionAttribute. Para obter mais informações sobre o atributo da versão informativa, consulte Definindo Atributos do Assembly.
Posicionamento do Assembly Para a maioria dos aplicativos .NET Framework, você localiza assemblies que compõem um aplicativo no diretório do aplicativo, em uma subpasta da pasta do aplicativo ou no cache global de assemblies (se o assembly for compartilhado). Você pode substituir onde o Common Language Runtime procura por um assembly, usando o elemento em um arquivo de configuração. Se o assembly não tiver um nome forte, a localidade especificada usando o elemento é restrita para o diretório do aplicativo ou para a subpasta. Se o assembly tiver um nome forte, o elemento pode especificar qualquer localidade no computador ou em uma rede.
Visual C# Consolidado
447
Regras similares se aplicam à localização de assemblies ao trabalhar com código não gerenciado ou aplicativos interop COM: se o assembly será compartilhado por vários aplicativos, ele deverá ser instalado no cache global de assemblies. Assemblies usados com códigos não gerenciados devem ser registrados e exportados como uma biblioteca de tipos. Assemblies usados pelo COM interop devem ser registrados no catálogo, embora em alguns casos, esse registro ocorra automaticamente.
Assemblies e execução lado a lado Execução lado a lado é a capacidade de armazenar e executar várias versões de um aplicativo ou componente no mesmo computador. Isso significa que você pode ter várias versões do runtime, e várias versões de aplicativos e componentes que usam uma versão do runtime, no mesmo computador ao mesmo tempo. A execução lado a lado lhe dá mais controle sobre quais versões de um componente um aplicativo está vinculado, e mais controle sobre que versão do Runtime um aplicativo usa. Suporte para armazenamento lado a lado e execução de diferentes versões do mesmo assembly é uma parte integral de nomeação forte e está embutido no infra-estrutura do Runtime. Pelo fato de o número da versão do assembly de nome forte fazer parte de sua identidade, o tempo de execução pode armazenar várias versões de o mesmo assembly no cache global de assemblies, e carregar esses módulos em tempo de execução. Embora o Runtime proporcione a capacidade para criar aplicativos lado a lado, a execução lado a lado não é automática. Para obter mais informações sobre a criação de aplicativos para execução lado a lado, consulte Diretrizes para criar aplicativos e componentes para execução lado a lado.
Visão Geral da Biblioteca de Classes do .NET Framework O .NET Framework inclui classes, interfaces e tipos de valor que aceleram e otimizam o processo de desenvolvimento e fornecem acesso à funcionalidades do sistema. Para facilitar a interoperabilidade entre linguagens, os tipos do .NET Framework são compatíveis com CLS e, portanto, podem ser usados por qualquer linguagem de programação cujo compilador está de acordo com a CLS (Common Language Specification). Os tipos do .NET Framework compões a base na qual os aplicativos, componentes e controles do .NET são criados. O .NET Framework inclui tipos que executam as seguintes funções: •
Representar tipos de dados base e exceções.
•
Encapsular estruturas de dados.
•
Executar E/S.
•
Acessar informações sobre os tipos carregados.
•
Invocar as verificações de segurança do .NET Framework.
•
Fornecer acesso a dados, uma GUI detalhada do lado do cliente e uma GUI do lado do cliente controlada pelo servidor.
O .NET Framework fornece um rico conjunto de interfaces, bem como classes abstratas e concretas. Você pode usar diretamente as classes concretas ou pode derivar suas próprias classes a partir delas. Para usar a funcionalidade de uma interface, você pode criar uma classe que implementa a interface ou derivar uma classe de uma das classes do .NET Framework que implementa a interface. Convenções de Nomenclatura
Visual C# Consolidado
448
Os tipos do .NET Framework usam um esquema de nomenclatura de sintaxe de ponto que dá a idéia de hierarquia. Essa técnica agrupa tipos relacionados em namespaces para que os tipos possam ser procurados e referenciados mais facilmente. A primeira parte do nome completo — até o ponto mais a direita — constitui o nome do namespace. A última parte do nome é o nome do tipo. Por exemplo, System.Collections.ArrayList representa o tipo ArrayList que pertence ao namespace System.Collections. Os tipos em System.Collections podem ser usados para manipular coleções de objetos. Esse esquema de nomenclatura facilita, para os desenvolvedores de bibliotecas, a extensão do .NET Framework a fim de criar grupos hierárquicos de tipos e nomeá-los de uma maneira consistente e informativa. Espera-se que os desenvolvedores de bibliotecas usem as seguintes diretrizes ao criar nomes para seus namespaces: NomeDaEmpresaNomeDaTecnologia Por exemplo, o namespace Microsoft.Word está de acordo com essa diretriz. O uso de padrões de nomenclatura para agrupar tipos relacionados em namespaces é uma maneira muito útil de criar e documentar bibliotecas de classes. Entretanto, esse esquema de nomenclatura não tem efeito sobre a visibilidade, acesso a membro, herança, segurança ou vinculação. Um namespace pode ser particionado em vários assemblys. Um único assembly pode conter tipos de vários namespaces diferentes. O assembly fornece a estrutura formal para o versionamento, a implantação, a segurança, o carregamento e a visibilidade no Common Language Runtime. Para obter mais informações sobre namespaces e nomes de tipos, consulte CTS (Common Type System). O Namespace System O namespace System é o namespace raiz para tipos fundamentais do .NET Framework. Esse namespace inclui classes que representam os tipos de dados base usados por todos os aplicativos: Object (a raiz da hierarquia de herança), Byte, Char, Array, Int32, String, etc. Muitos desses tipos correspondem aos tipos de dados primitivos que são usados pelas linguagens de programação. Quando você escreve um código usando os tipos do .NET Framework, você pode usar a correspondente palavra-chave da linguagem onde um tipo de dado base do .NET Framework é esperado. A tabela a seguir lista alguns dos tipos de valor que são fornecidos pelo .NET Framework. É dada uma breve descrição cada tipo e uma indicação do tipo correspondente em Visual Basic, C# e C++. A tabela também inclui entradas para a classes Object e String, para as quais várias linguagens possuem as palavras-chave correspondentes. Tipo de dado em Visual Basic
Tipo de Tipo de dado em dado em C# C++
Tipo de dado em JScript
Categoria
Nome da classe
Inteiro
Byte
Um inteiro de 8 bits sem sinal.
Byte
Byte
char
Byte
SByte
Um inteiro de 8 bits com sinal. Não compatível com CLS.
SByte
sbyte
signed char
SByte
Int16
Um inteiro de 16 bits com sinal.
Short
short
short
short
Descrição
Visual C# Consolidado
449
Int32
Um inteiro de 32 bits com sinal.
Integer
int
int -oulong
int
Int64
Um inteiro de 64 bits com sinal.
Long
long
__int64
long
UInt16
Um inteiro e 16 bits sem sinal. Não compatível com CLS.
UShort
ushort
unsigned short
UInt16
UInt32
Um inteiro de 32 bits sem sinal. Não compatível com CLS.
UInteger
uint
unsigned int -ouunsigned long
UInt32
UInt64
Um inteiro de 64 bits sem sinal. Não compatível com CLS.
ULong
ulong
unsigned __int64
UInt64
Single
Número de ponto flutuante Single de precisão simples (32 bits).
float
float
float
Double
Número de ponto flutuante Double de precisão dupla (64 bits).
double
double
double
Lógico
Boolean
Um valor booleano (true ou false).
Boolean
bool
bool
bool
Outros
Char
Um caractere unicode (16 bits).
Char
char
wchar_t
char
Decimal
Um valor decimal (128 bits).
Decimal
decimal
Decimal
Decimal
IntPtr
Um inteiro com sinal cujo tamanho depende da plataforma subjacente (um valor de 32 bits em uma plataforma de 32 bits e um valor de 64 bits em uma plataforma de 64 bits).
IntPtr Nenhum tipo interno.
IntPtr Nenhum tipo interno.
IntPtr Nenhum tipo interno.
IntPtr
UIntPtr
Um inteiro sem sinal cujo tamanho depende da plataforma subjacente (um valor de 32 bits em uma plataforma de 32 bits e um valor de 64 bits em uma plataforma de 64 bits). Não compatível com CLS.
UIntPtr Nenhum tipo interno.
UIntPtr Nenhum tipo interno.
UIntPtr Nenhum tipo interno.
UIntPtr
A raiz da hierarquia de objeto.
Object
object
Object*
Object
Uma seqüência de String caracteres Unicode imutável e de comprimento fixo.
string
String*
String
Ponto flutuante
Objetos de Object Classe String
Visual C# Consolidado
450
Além dos tipos de dados base, o namespace System contém mais de 100 classes, variando de classes que tratam exceções a classes que lidam com os principais conceitos do ambiente de execução, como domínios de aplicativo e coleta de lixo. O namespace System também contém vários namespaces de segundo nível. Para obter mais informações sobre namespaces, consulte a Referência do .NET Framework. Essa documentação fornece uma visão geral sobre cada namespace, assim como uma descrição formal de cada tipo e de seus membros.
Localizador rápido de tecnologia A tabela a seguir fornece uma referência rápida para as principais áreas de tecnologias do .NET Framework. Para aprender sobre...
Consultar...
Biblioteca de classes do .NET Framework
Visão geral sobre a biblioteca de classes do .NET Framework
ADO.NET
ADO.NET
Domínios de aplicativos
Usando domínios de aplicativos
ASP.NET
Criando aplicativos ASP.NET Visão geral do ASP.NET Controles de servidores Web do ASP.NET
Assemblies
Programação com assemblies
Programação assíncrona
COMO: Encadear chamadas assíncronas com um método de Web Service
CodeDom
Geração e compilação dinâmicas de código fonte
Common Language Runtime
Common Language Runtime
Configuração
Configurando aplicativos Configurando aplicativos ASP.NET
Acesso a dados
Acesso a dados
Depuração
Depuração e perfil de aplicativos
Implantação
Implantação de ClickOnce para aplicativos de formulários do Windows Implantando aplicativos .NET Framework
Visual C# Consolidado
451
Noções básicas sobre implantação de .NET Framework Designers e o ambiente de design
Estendendo suporte em tempo de design
Eventos
Tratamento e disparada de eventos
Exceções
Tratamento e lançamento de exceções
Coleta de lixo
Coleta de lixo
GDI +
Elementos gráficos e desenho em formulários do Windows
Tipos genéricos
Reflexão e tipos genérico
E/S
E/S de arquivo e de fluxo
Interoperabilidade
Interoperabilidade
Desenvolvimento móvel
.NET Compact Framework Criando aplicativos móveis ASP .NET
Redes
Programação de redes
Reflexão
Reflexão
Arquitetura de comunicação remota Objetos remotos Visão geral sobre a arquitetura de comunicação remota do .NET Framework Segurança
Segurança no .NET Framework Conceitos chaves sobre segurança
Componentes atendidos
Escrevendo componentes atendidos Visão geral sobre componentes atendidos
Serialização
Serialização
Execução lado a lado
Execução lado a lado
Threads
Threads gerenciadas
Formulários do Windows
Formulários do Windows no .NET Framework
Visual C# Consolidado
452
Controles de formulários do Windows
Controles de formulários do Windows
XML
Documentos e dados XML
XML Web Services
Visão geral sobre XML Web Services
Como Criar uma Listagem de Diretório O exemplo de código a seguir mostra como usar as classes de E/s para criar uma lista de todos os arquivos com a extensão ".exe " em um diretório. Exemplo C# using System; using System.IO; class DirectoryLister { public static void Main(String[] args) { string path = "."; if (args.Length > 0) { if (File.Exists(args[0]) { path = args[0]; } else { Console.WriteLine("{0} not found; using current directory:", args[0]); } DirectoryInfo dir = new DirectoryInfo(path); foreach (FileInfo f in dir.GetFiles("*.exe")) { String name = f. Name; long size = f.Length; DateTime creationTime = f.CreationTime; Console.WriteLine("{0,-12:N0} {1,-20:g} {2}", size, creationTime, name); } } }
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.
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 <= balance ); savingsAccount.Withdraw ( amount );
Antes que retirar dinheiro da conta, você deseja verificar se o saldo da conta é suficiente para cobrir a quantidade que você está preparando para saque. Você pode escrever uma asserção para verificar o saldo: [C#] float balance = savingsAccount.Balance; Trace.Assert ( amount <= balance ); savingsAccount.Withdraw ( amount );
Observe que chamadas ao método System.Diagnostics.Debug.Assert(System.Boolean) desaparecem quando você cria uma versão de lançamento do seu código. Isso significa que a
Visual C# Consolidado
543
chamada que verifica o saldo desaparece na versão de lançamento. Para solucionar esse problema, você deve substituir System.Diagnostics.Debug.Assert(System.Boolean) por System.Diagnostics.Trace.Assert(System.Boolean), que não desaparece na versão de lançamento: Chamadas para System.Diagnostics.Trace.Assert(System.Boolean) Adicionam sobrecarga a sua versão de lançamento, diferentemente de chamadas para System.Diagnostics.Debug.Assert(System.Boolean). Efeitos colaterais de Debug.Assert Quando você usar System.Diagnostics.Debug.Assert(System.Boolean), certifique-se de que qualquer código dentro do Assert não altera os resultados do programa se Assert for removido. Caso contrário, você pode introduzir um erro que aparece somente na versão de lançamento do seu programa acidentalmente. Tome cuidado principalmente com asserções que contêm chamadas de função ou procedimento, como o exemplo a seguir: [C#] // unsafe code Debug.Assert (meas(i) != 0 );
Este uso de System.Diagnostics.Debug.Assert(System.Boolean) pode parecer seguro a princípio, mas suponha que a meas da função atualiza um contador sempre que ela é chamada. Quando você cria a versão de lançamento, esta chamada para meas é eliminada, para o contador não ser atualizado. Este é um exemplo de uma função com um efeito colateral. Eliminar uma chamada para uma função que tem efeitos colaterais pode resultar em um erro que aparece apenas na versão de lançamento. Para evitar esses problemas, não posicione chamadas de função em uma instrução System.Diagnostics.Debug.Assert(System.Boolean). Use uma variável temporária: [C#] temp = meas( i ); Debug.Assert ( temp != 0 );
Mesmo quando você usa System.Diagnostics.Trace.Assert(System.Boolean), ainda convém evitar fazer chamadas de função dentro de uma instrução Assert. Essas chamadas deverão ser seguro, pois instruções System.Diagnostics.Trace.Assert(System.Boolean) não são eliminados em uma criação para lançamento. No entanto, se você evitar tais construções como uma questão de hábito, é menos provável que você cometa um erro quando você usa System.Diagnostics.Debug.Assert(System.Boolean). Requisitos de Depuração e Rastreamento Se você criar o projeto usando os assistentes Visual Studio, o símbolo Trace é definido por padrão em Configurações de lançamento e de depuração. O símbolo Debug é definido por padrão somente na compilação de depuração. Caso contrário, para métodos Trace funcionarem, o programa deve ter uma das opções a seguir na parte superior do arquivo de origem: •
#Const TRACE = True no Visual Basic
•
#define TRACE Em Visual C++ e C#
Ou o programa deve ser criado com a opção Trace:
Visual C# Consolidado
544
•
/d:TRACE=True No Visual Basic
•
/d:TRACE Em Visual C# e C++
Se você precisa usar os métodos de depuração em uma criação de versão C# ou Visual Basic, você deverá definir o símbolo Debug em sua configuração de lançamento. C++ não dá suporte a métodos de classe Debug. Você pode obter o mesmo efeito, usando a classe Trace com compilação condicional, tais como #ifdef DEBUG... #endif Você pode definir esses símbolos na caixa de diálogo Property Pages. Para obter mais informações, consulte Alterando configurações do projeto para configuração de depuração no Visual Basic ou Alterando Configurações do projeto para configuração de depuração em C ou C++. Declarar argumentos System.Diagnostics.Trace.Assert(System.Boolean) e System.Diagnostics.Debug.Assert(System.Boolean) levam até três argumentos. O primeiro argumento, que é obrigatório, é a condição que deseja verificar. Se você chamar System.Diagnostics.Trace.Assert(System.Boolean) ou System.Diagnostics.Debug.Assert(System.Boolean) com apenas um argumento, o método Assert verificará a condição e, se o resultado é False, mostra o conteúdo da pilha de chamadas na janela Output. O exemplo a seguir Mostra System.Diagnostics.Trace.Assert(System.Boolean) e System.Diagnostics.Debug.Assert(System.Boolean): [C#] Debug.Assert ( stacksize > 0 ); Trace.Assert ( stacksize > 0 );
Os argumentos segundo e terceiro, se houver, devem ser seqüências. Se você chamar System.Diagnostics.Trace.Assert(System.Boolean) ou System.Diagnostics.Debug.Assert(System.Boolean) com dois ou três argumentos, o primeiro argumento é uma condição. O método verifica a condição e, se o resultado for FALSO, mostra a segunda e terceira seqüências. O exemplo a seguir mostra System.Diagnostics.Debug.Assert(System.Boolean,System.String) e System.Diagnostics.Trace.Assert(System.Boolean,System.String) usado com dois argumentos: [C#] Debug.Assert ( stacksize > 0, "Out of stack space" ); Trace.Assert ( stacksize > 0, "Out of stack space" );
O exemplo a seguir Mostra Assert e Assert: [C#] Debug.Assert ( stacksize > 100, "Out of stack space" , "Failed in inctemp" ); Trace.Assert ( stacksize > 0, "Out of stack space", "Failed in inctemp" );
Personalizando comportamento de declaração Se você executar o aplicativo no modo de interface do usuário, o método Assert exibe a caixa de diálogo Assertion Failed quando a condição falhar. As ações que ocorrem quando uma declaração falha são controladas pela propriedade Listeners ou Listeners. Você pode personalizar o comportamento de saída adicionando um objeto TraceListener à coleção Listeners, removendo um TraceListener da coleção Listeners, ou substituindo o método
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<10; x++)
Suponha que você definir um ponto de interrupção nesta linha. Você pode esperar o ponto de interrupção para ser atingido 10 vezes, mas se o código é otimizado, ponto de interrupção somente é acertado uma vez. Que é porque a primeira instrução define o valor da x como 0. O compilador reconhece que isso só tem que ser feito uma vez e move-fora do loop. Move o ponto de interrupção a ele. As instruções que comparar e incrementar x permanecer dentro do loop. Quando você exibe a Disassembly janela é automaticamente definida como instrução para maior controle, que é útil quando depuração através de código otimizado. o Unidade etapa
DebugBreak e __debugbreak 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
Você pode chamar a DebugBreak função Win32 ou __debugbreak. intrínsecas em qualquer ponto no seu código e DebugBreak__debugbreak ter o mesmo efeito que configurar um ponto de interrupção nesse local. Porque DebugBreak é uma chamada para uma função do sistema, depuração do sistema símbolos devem ser instalados para garantir a informação correta pilha de chamadas é exibida após quebra. Caso contrário, as informações exibidas pelo depurador pilha de chamadas podem estar fora por um quadro. Não se você usar __debugbreak, símbolos são necessários.
Declarações Este tópico se aplica a: Visual Studio Edition
Visual Basic
Visual C# Consolidado
C#
C++
J#
553
Express Edition
Não
Não
Nativo
Não
Standard Edition
Não
Não
Nativo
Não
Pro / Team Edition
Não
Não
Nativo
Não
Uma instrução de declaração Especifica uma condição que você espera para manter verdadeira em algum momento específico em seu programa. Se essa condição não tem verdadeira, a declaração falhar, execução de seu programa for interrompida, aparece. e Caixa de diálogo Falha de declaração Visual C++ oferece suporte instruções de declaração com base nas seguintes construções: •
Para Declarações MFC Programa MFC.
•
Para ATLASSERT programas que utilizam ATL.
•
Para Declarações CRT programas que utilizam a biblioteca de tempo de execução C.
•
O ANSI Declarar função para outros programas C/C.
Você pode usar declarações para: Capturar erros de lógica. Para obter mais informações, consulte Erro Catching de lógica.
• •
Verificar resultados de uma operação. Para obter mais informações, consulte Resultado de verificação.
•
Teste as condições de erro que devem ter sido tratadas. Para obter mais informações, consulte Teste condição de erro.
MFC e Assertions C Run-Time Library Quando o depurador pára devido a uma declaração Biblioteca de tempo de execução MFC ou C, ele navega até o ponto no arquivo de origem onde a declaração ocorreu (se a fonte estiver disponível). A mensagem de declaração aparece na caixa de diálogo, bem como Janela de saída o Assertion Failed. Você pode copiar a mensagem de declaração da janela Output para uma janela de texto se você desejar salvá-lo para referência futura. A Output janela pode conter outras mensagens de erro, bem. Examinar essas mensagens com cuidado, pois fornecem pistas para a causa da falha de declaração. Através do uso liberal de declarações em seu código, você pode capturar muitos erros durante o desenvolvimento. Uma boa regra é para escrever uma declaração para cada suposição você fazer. Se você assumir que um argumento não é NULL, por exemplo, usar uma instrução de declaração para verificar essa suposição. _DEBUG Instruções de declaração compilar somente quando _DEBUG for definida. Quando _DEBUG não for definido, o compilador trata declarações como instruções nulas. Assim, instruções de declaração ter zero sobrecarga no seu programa versão final; você pode usá-los liberally em seu código, sem afetar o desempenho da sua versão release e sem que seja necessário usar #ifdef as diretivas. Efeitos lado do uso Assertions
Visual C# Consolidado
554
Quando você adicionar declarações a seu código, certifique-se que as declarações não tem efeitos colaterais. Por exemplo, considere a declaração a seguir: ASSERT(nM++ > 0); // Don't do this!
Porque a ASSERT expressão não é avaliada com a versão release do seu programa, nM terá que valores diferentes nas versões Debug e Release. Em MFC, você pode usar a VERIFY macro em vez de ASSERT. Avaliará VERIFY a expressão mas não verifica o resultado na versão Release. Tenha cuidado usando chamadas de função em instruções de declaração, especialmente como avaliar uma função pode ter efeitos colaterais inesperados. ASSERT ( myFnctn(0)==1 ) // unsafe if myFnctn has side effects VERIFY ( myFnctn(0)==1 ) // safe
Chama VERIFYmyFnctn em versões Debug e Release, portanto é aceitável para usar. Você ainda terá a sobrecarga de um chamada de função desnecessária na versão Release, entretanto.
Detecção vazamento de memória e isolamento 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#
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 //
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 <= n; i++) { p = nextPrime(p); yield return new primeIndex(i, p); } } private static void Fill(object source, out int n, out int p, out SqlDouble est) { primeIndex pi = (primeIndex)source; n = pi.n; p = pi.p; if (n <5) est = SqlDouble.Null; else { double log = Math.Log(n); double loglog = Math.Log(log); est = n * (log + loglog - 1 + loglog / log - 2 / log); } } }
Este é o script de teste que chama a função. SELECT n,p,est FROM dbo.TableOfPrimes(50) SELECT TOP 10 n, p, est, est/p AS factor FROM dbo.TableOfPrimes(500) ORDER BY factor DESC SELECT TOP 10 n, p, est, est/p AS factor FROM dbo.TableOfPrimes(1000) WHERE n>500 ORDER BY factor DESC
Passo-a-passo: Depuração de um disparador SQL CLR Este 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
Este exemplo mostra como depurar um disparador CLR SQL. Ele usa a tabela Contact no banco de dados de exemplo AdventureWorks, que é um dos bancos de dados instalado com SQL Server 2005. O exemplo cria um novo disparador CLR inserir na tabela Contact.
Visual C# Consolidado
583
Observação As caixas de diálogo e comandos de menu você vê pode diferir daquelas descritas na ajuda dependendo de suas configurações ativas ou versão. Para alterar as configurações, escolha Import and Export Settings no menu Tools. Para obter mais informações, consulte Configurações Visual Studio. Para depurar um disparador CLR SQL: 1.
Em um novo projeto do SQL Server, estabelecer uma conexão para o banco de dados AdventureWorks. Para obter mais informações, consulte Como conectar-se a um banco de dados:.
2.
Criar um novo disparador usando o código da primeira seção do exemplo abaixo, e nomeá-lo iContact.cs. Para obter mais informações, consulte Como Develop com o tipo do Project Server SQL:.
3.
Adicionar um script que testa o disparador gerando uma ativação. No Solution Explorer clique com o botão direito do mouse no diretório TestScripts, clique Add Test Script, e insira o código da segunda seção do exemplo abaixo. Salve o arquivo com o nome truContact.sql. Clique com o botão direito do mouse no nome de arquivo e clique em Set as Default Debug Script.
4.
Defina pontos de interrupção no iContact.cs, e clique em Start do menu Debug para compilar, implantar e testar a unidade do projeto. Quando o ponteiro de instrução, designado por uma seta amarela, aparecer em um ponto de interrupção, você está depurando o disparador.
5.
Experimente recursos de depuração diferentes. 1. 2.
Passe a instrução instanciando o SqlTriggerContext. Abra a janela Locals. Observe que você pode abrir a variável triggContext, que é a SqlTriggerContext, e você pode examinar seus membros. Para obter mais informações, consulte Como: usar janelas variáveis do depurador. Observação
O servidor pode não refletir as alterações em valores de variáveis nas janelas do depurador. Par obter mais informações, consulte Limitações depuração SQL. 3.
Escolha Step Into no menu Debug para passar uma linha na stored procedure. Observe que a execução tem instanciado o valor da variável sqlP do tipo SqlPipe.
4.
Abra a janela Watch. Arraste a variável sqlP para qualquer local na janela Watch. A variável agora é adicionada à lista de variáveis observadas. Para obter mais informações, consulte Como: usar janelas variáveis do depurador. Observação Você pode editar os valores das variáveis na janela Watch.
5.
No editor de texto, clique com o botão direito do mouse na linha última e clique em Insert Breakpoint.
6.
No menu Debug, clique Continue e o depurador executará o código até o novo ponto de interrupção.
Visual C# Consolidado
584
6.
Clique Continue novamente para concluir a depuração do disparador. Uma mensagem aparece na janela Output informando que o disparador foi depurado com êxito e exibe o resultado da execução dos comandos no arquivo truContact.sql.
Exemplo Isso é o código necessário para criar o disparador usado neste exemplo. using System; using System.Data; using System.Data.Sql; using Microsoft.SqlServer.Server; public partial class Triggers { // Enter existing table or view for the target and uncomment the attribute line. [Microsoft.SqlServer.Server.SqlTrigger (Name="Trigger1", Target="primes", Event="FOR UPDATE")] public static void Trigger1() { SqlTriggerContext triggContext = SqlContext.TriggerContext; SqlPipe sqlP = SqlContext.Pipe; sqlP.Send("primes inserted!"); } }
Este é o script de teste que fará com que o disparador seja acionado. UPDATE Person.Contact SET MiddleName = 'A' WHERE ContactID = 8
Passo-a-passo: Depuração de um tipo SQL CLR definido pelo usuário 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 um tipo SQL CLR definido pelo usuário. Ele cria um novo tipo SQL CLR no banco de dados de exemplo AdventureWorks. O tipo depois é usado em uma definição de tabela, uma instrução INSERT, e em seguida em uma instrução SELECT. Observação 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 um tipo CLR SQL definido pelo usuário 1.
Em um novo projeto do SQL Server, estabeleça uma conexão com a banco de dados de exemplo AdventureWorks. Para obter mais informações, consulte Como conectar-se a um banco de dados:.
2.
Crie um novo tipo usando o código da primeira seção exemplo abaixo, e nomeie-a Point.cs. Para obter mais informações, consulte Como Develop com o tipo do Project Server SQL:.
Visual C# Consolidado
585
3.
4.
Adicione um script que testa o tipo. No Solution Explorer, clique com o botão direito do mouse no diretório TestScripts , clique Add Test Script, e insera o código da segunda seção de exemplo abaixo. Salve o arquivo com o nome Point.sql. Clique com o botão direito do mouse no nome de arquivo, e clique em Set as Default Debug Script. Adicione pontos de interrupção. 1. 2.
5.
6.
Na pasta Types no Server Explorer, abra Point. Insira um ponto de interrupção dentro de cada método de modo que você possa observar o fluxo de controle no interior do tipo.
A partir do menu Debug, escolha Start para compilar, implantar, e testar o projeto. Quando o ponteiro de instrução, designado por uma seta amarela, aparecer no ponto de interrupção, você está depurando sua função. Experimente recursos de depuração diferentes. 1.
O método Parse é executado uma vez para cada instrução INSERT no script no Point.sql. Repetidamente clicando Step Into no Debug menu, você pode observar como o método converte um par de números delimitado por dois-pontos em um objeto Point.
2.
Na janela Locals, abra a variável pt, que contém o Point que está sendo criado atualmente.
3.
No editor de texto, clique duas vezes a variável pt para selecioná-la. Arraste pt para qualquer local na janela Watch. Agora pt é adicionado à lista de variáveis observadas, e você pode observá-la comforme o Point é executado.
4.
Depurar a classe várias vezes e observar as diferenças entre os caminhos de um INSERT e um SELECT.
5.
Pressione Continue novamente para concluir a depuração da função.
Exemplo Isso é o código que define o tipo usado neste exemplo. Este código cria uma tabela denominada pontos, insere linhas nela, e imprime o conteúdo da tabela. Observe que você não deve incluir o comando em lote GO entre a criação da tabela e seu acesso. Na verdade Visual Studio 2005 interpretará o GO como um comando SQL inválido. using System; using System.Data.Sql; using System.Data.SqlTypes; using System.Runtime.Serialization; [Serializable, SqlUserDefinedTypeAttribute(Format.Native)] public struct Point: INullable { private bool m_isNull; private double m_x; private double m_y; public bool IsNull { get { return (m_isNull); } } public override string ToString() { if (this.IsNull) { return "NULL"; } else { return this.m_x + ":" + this.m_y; } } public static Point Parse(SqlString s) { if (s.IsNull) { return Null; } else { // Parse input string here to separate out points: Point pt = new Point(); string str = Convert.ToString(s); string[] xy = str.Split(':'); pt.X = Convert.ToDouble(xy[0]); pt.Y = Convert.ToDouble(xy[1]); return (pt); } } public static Point Null { get { Point pt = new Point(); pt. m_isNull = true; return (pt); } } public double X { get { return (this.m_x); } set { m_x = value; } } public double Y { get { return (this.m_y); } set { m_y = value; } } }
Este é o script de teste que chama a função. CREATE TABLE dbo.Points ( ID int IDENTITY(1,1) PRIMARY KEY, Pnt Point) INSERT INTO dbo.Points (Pnt) VALUES (CONVERT(Point, '3:4')) INSERT INTO dbo.Points (Pnt) VALUES (CONVERT(Point, '-1:5')) INSERT INTO dbo.Points (Pnt) VALUES (CAST ('1:99' AS Point)) SELECT ID, Pnt.ToString() as StringPoint, Pnt.X as X, Pnt.Y as Y FROM dbo.Points
Visual C# Consolidado
586
Passo-a-passo: Depuração de uma função SQL CLR escalar definida pelo usuário 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
Este exemplo mostra como depurar uma função SQL CLR definida pelo usuário (UDF). Ele cria uma nova função SQL CLR definida pelo usuário no banco de dados de exemplo AdventureWorks. Observação As caixas de diálogo e comandos de menu você vê podem diferir daquelas descritas na ajuda dependendo das suas configurações ativas ou versão. Para alterar as configurações, escolha Import and Export Settings no menu Tools. Para obter mais informações, consulte Configurações Visual Studio. Para depurar uma função escalar CLR SQL definida pelo usuário 1.
Em um novo projeto do SQL Server, estabeleça uma conexão com a banco de dados de exemplo AdventureWorks. Para obter mais informações, consulte Como conectar-se a um banco de dados:.
2.
Criar uma nova função usando o código da primeira seção do exemplo abaixo, e nomeá-la OrderCount.cs. Para obter mais informações, consulte Como Develop com o tipo do Project Server SQL:.
3.
Adicionar um script que testa a função incluindo-o em uma instrução SELECT. No Solution Explorer, clique com o botão direito do mouse no diretório TestScripts, clique Add Test Script e insira o código da segunda seção do exemplo abaixo. Salve o arquivo com o nome CallOrderCount.sql. Clique com botão direito mouse no nome do arquivo e escolha Set as Default Debug Script.
4.
Coloque um ponto de interrupção no OrderCount.cs na linha que instancia um SqlCommand, e no menu Debug, clique Start para compilar, implantar e testar a unidade do
projeto. Quando o ponteiro de instrução, designado por uma seta amarela, aparecer no ponto de interrupção, você está depurando sua função. 5.
Experimentar recursos de depuração diferentes. 1.
Passe a instrução instanciando o SqlCommand usando Step Into a partir do menu Debug.
2.
Na janela Locals, abra a variável sqlComm, que é o SqlCommand e examine seus membros.
3.
Clique Step Into no menu Debug para passar uma linha na função. Observe que o membro sqlComm.CommandText foi instanciado tem.
Visual C# Consolidado
587
4.
No editor de texto, arraste sqlComm para qualquer local na janela Watch. A variável agora é adicionada à lista de variáveis observadas.
5.
Escolha Step Into novamente e observe que uma nova janela rotulada Dynamic TSQL abre, exibindo a instrução SQL que está prestes a ser executada.
6. 7.
Escolha Step Into por executar a instrução e retornar para a função. Pressione Continue novamente, e observe a segunda janela Dynamic T-SQL que abre, mostrando o código que retorna o valor da função.
8.
Pressione Continue novamente para concluir a depuração da função.
Exemplo Isso é o código necessário para criar a função. using System; using System.Data.SqlClient; using Microsoft.SqlServer.Server; public partial class UserDefinedFunctions { [Microsoft.SqlServer.Server.SqlFunction(DataAccess = DataAccessKind.Read)] public static int OrderCount() { using (SqlConnection conn = new SqlConnection("context connection=true")) { conn.Open(); SqlCommand cmd = new SqlCommand(); cmd.Connection = conn; cmd.CommandText = "SELECT 42"; //cmd = new SqlCommand("SELECT 42",conn); int result = (int)cmd.ExecuteScalar(); return result; } } };
Este é o script de teste que chama a função. SELECT dbo.OrderCount()
Passo-a-passo: Depuração de uma agregação SQL CLR definida pelo usuário Este tópico se aplica a: Edição 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 CLR SQL agregada definida pelo usuário. Ele cria uma nova função CLR SQL agregada chamada Concatenate no banco de dados de exemplo AdventureWorks. Quando esta função é chamada em uma instrução SQL, ela irá concatenar todos os valores para coluna especificada como seu parâmetro de entrada. Observação As caixas de diálogo e comandos de menu que você vê podem diferir daquelas descritas na Ajuda dependendo da 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.
Visual C# Consolidado
588
Para depurar uma função CLR SQL agregada 1.
Em um novo projeto do SQL Server, estabeleça uma conexão com o banco de dados de exemplo AdventureWorks. Para obter mais informações, consulte Como conectar-se a um banco de dados:.
2.
Crie uma nova função usando o código do primeiro dos exemplo de seções a seguir e denomine-o Concatenate.cs. Para obter mais informações, consulte Como Develop com o tipo do Project Server SQL:.
3.
Adicione um script que testa a função, incluindo-o em uma instrução SELECT. No Solution Explorer clique com o botão direito do mouse no diretório TestScripts, selecione Add Test Script, e insira o código da segunda seção de exemplo abaixo. Salve o arquivo com o nome Concatenate.sql. Clique com o botão direito do mouse no nome de arquivo, e clique em Set as Default Debug Script.
4.
Coloque um ponto de interrupção na Concatenate.cs dentro do método Accumulate na instrução if. Para fazer isso, clique na margem esquerda cinza da janela do editor de texto, e no menu Debug, clique em Start, para compilar, implantar, e testar a unidade do projeto. Quando o ponteiro de instrução, designado por uma seta amarela, aparecer no ponto de interrupção, significa que você está depurando sua função.
5.
Experimente recursos de depuração diferentes. 1.
O método Accumulate é executado uma vez para cada linha que constitui a cláusula GROUP BY em script na Concatenate.sql. Repetidamente clicando Step Into no menu Debug, você pode observar como o resultado do método é criado.
2.
Na janela Locals, abra a variável value, que contém o nome de armazenamento atual sendo processado.
3.
Clique na variável this. O nó filho intermediateResult será retornado dessa função, e contém todos os nomes de armazenamento até o armazenamento presente, concatenados juntos e separados por vírgulas.
4.
No editor de texto, clique duas vezes a variável intermediateResult para selecioná-lo. Arraste intermediateResult para a janela Watch e solte-a em qualquer lugar na janela. A variável agora é adicionada à lista de variáveis observadas.
5.
Avançe pelo método várias vezes. O valor de intermediateResult será alterado toda vez através do método, com um nome de armazenamento adicional concatenado até o final.
6.
Clique no ponto de quebra para removê-la, e adicione um ponto de quebra para a primeira instrução dentro do método Terminate. Esse método retorna o resultado para o chamador. Para avançar por ele, no menu Debug, clique em Start. Você pode agora depurar por ele clicando Step Into no menu Debug. Pare quando você chegar na instrução return.
7.
Clique em Continue novamente para concluir a depuração da função.
Exemplo Este é o código para a função agregada usada no exemplo. using System; using System.Data.Sql; using System.Data.SqlTypes; using System.Data.SqlServer; using System.IO; using System.Text; [Serializable] [SqlUserDefinedAggregate( //use CLR serialization to serialize the intermediate result. Format.UserDefined, //Optimizer property: IsInvariantToNulls=true, //Optimizer property: IsInvariantToDuplicates=false, //Optimizer property: IsInvariantToOrder=false, //Maximum size in bytes of persisted value: MaxByteSize=8000) ] public class Concatenate: IBinarySerialize { /// /// Variable holds intermediate result of the concatenation /// private StringBuilder intermediateResult; /// /// Initialize the internal data structures ///
Visual C# Consolidado
589
public void Init( ) { intermediateResult = new StringBuilder(); } /// /// Accumulate the next value, nop if the value is null /// /// public void Accumulate(SqlString value) { if(value.IsNull) { return; } intermediateResult.Append(value.Value).Append(','); } /// /// Merge the partially computed aggregate with this aggregate. /// /// public void Merge( Concatenate other) { intermediateResult.Append(other.intermediateResult); } /// /// Called at end of aggregation, to return results. /// /// public SqlString Terminate() { string output = string.Empty; //Delete the trailing comma, if any . if (intermediateResult != null && intermediateResult.Length > 0) output = intermediateResult.ToString(0, intermediateResult.Length-1); return new SqlString(output); } public void Read(BinaryReader r) { intermediateResult = new StringBuilder(r.ReadString()); } public void Write(BinaryWriter w) { w.Write(intermediateResult.ToString()); } }
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 <= 0) throw new ArgumentException("Buffer"); if (Buffer == null) throw new ArgumentNullException("Buffer"); // Encrypt the data in memory. The result is stored in the same same array as the original data. ProtectedMemory.Protect(Buffer, Scope); } public static void DecryptInMemoryData(byte[] Buffer, MemoryProtectionScope Scope) { if (Buffer.Length <= 0) throw new ArgumentException("Buffer"); if (Buffer == null) throw new ArgumentNullException("Buffer"); // Decrypt the data in memory. The result is stored in the same same array as the original data. ProtectedMemory.Unprotect(Buffer, Scope); } public static byte[] CreateRandomEntropy() { // Create a byte array to hold the random value. byte[] entropy = new byte[16]; // Create a new instance of the RNGCryptoServiceProvider. // Fill the array with a random value. new RNGCryptoServiceProvider().GetBytes(entropy); // Return the array. return entropy; } public static int EncryptDataToStream(byte[] Buffer, byte[] Entropy, DataProtectionScope Scope, Stream S) { if (Buffer.Length <= 0) throw new ArgumentException("Buffer"); if (Buffer == null) throw new ArgumentNullException("Buffer"); if (Entropy.Length <= 0) throw new ArgumentException("Entropy"); if (Entropy == null) throw new ArgumentNullException("Entropy"); if (S == null) throw new ArgumentNullException("S"); int length = 0; // Encrypt the data in memory. The result is stored in the same same array as the original data. byte[] encrptedData = ProtectedData.Protect(Buffer, Entropy, Scope); // Write the encrypted data to a stream. if (S.CanWrite && encrptedData != null) { S.Write(encrptedData, 0, encrptedData.Length); length = encrptedData.Length; } // Return the length that was written to the stream.
Visual C# Consolidado
606
return length; } public static byte[] DecryptDataFromStream(byte[] Entropy, DataProtectionScope Scope, Stream S, int Length) { if (S == null) throw new ArgumentNullException("S"); if (Length <= 0 ) throw new ArgumentException("Length"); if (Entropy == null) throw new ArgumentNullException("Entropy"); if (Entropy.Length <= 0) throw new ArgumentException("Entropy"); byte[] inBuffer = new byte[Length]; byte[] outBuffer; // Read the encrypted data from a stream. if (S.CanRead) { S.Read(inBuffer, 0, Length); outBuffer = ProtectedData.Unprotect(inBuffer, Entropy, Scope); } else { throw new IOException("Could not read the stream."); } // Return the length that was written to the stream. return outBuffer; } }
Compilando o código Incluir uma referência para System.Security.dll.
• •
Incluir e System.Text Espaço para nome., System.Security.Cryptography a System, System.IO
COMO: Adicionar Permissões Personalizadas à Política de Segurança Uma permissão personalizada é um que é fornecido com um aplicativo ou biblioteca, em vez de sendo fornecido pelo .NET Framework. Para ser significativo, uma permissão personalizada deve ser adicionado com a diretiva de segurança no computador (ou computadores, no caso de uma rede) onde o aplicativo usando a permissão executa. Você deve descrever as especificações da permissão você deseja adicionar ao sistema de segurança do .NET Framework quando você adiciona ele sua diretiva personalizada. Uma permissão único pode assumir vários formulários que representam o direito de acessar recursos específicos. Por exemplo, a permissão personalizada pode ter a capacidade de fornecer acesso restrito ou irrestrito a um recurso. Como um administrador, você tem a capacidade de decidir qual tipo a permissão de acesso (restrito ou Irrestrito) representará. Portanto, você deve descrever a configuração que você deseja a permissão para tem que o sistema de segurança do .NET Framework. Isso, criando uma representação XML da configuração você deseja a permissão personalizada para ter e importar o XML para a diretiva de segurança. (O sistema de segurança do .NET Framework usa XML para serializar permissões.) O editor da permissão ou deve fornecer uma ferramenta para criar a representação XML ou fornecer instruções para criar o arquivo XML. Geralmente, as representações XML das permissões que compõem a diretiva de segurança são armazenadas em arquivos de configuração de diretiva. Para adicionar uma permissão personalizada à diretiva de segurança 1.
Adicionar Conjunto implementar a permissão personalizada para o cache de conjunto de módulos global e para a lista de conjuntos de módulos (assemblies) totalmente confiável.
2.
Criar um arquivo XML que representa o tipo de permissão você deseja criar e atribuir aos conjuntos.
3.
Adicionar a representação XML da permissão para a diretiva de segurança, usando o Ferramenta .NET Framework Configuration (Mscorcfg.msc) ou o Ferramenta Diretiva de segurança para acesso de código (Caspol.exe).
COMO: Ativar Configurações de Segurança do Internet Explorer para a Execução Gerenciada Como Microsoft Internet Explorer pode atuar como um host para controles gerenciados e componentes, suas configurações de segurança afetam execução gerenciado. O controle gerenciado pode executar no Internet Explorer, a menos controles ActiveX e scripts são ativados não. Para ativar as configurações de segurança do Internet Explorer 1.
No Internet Explorer, no Internet Options menu Tools.
Visual C# Consolidado
607
2.
Clique na Security guia. Você pode acessar as configurações para a zona da Internet, zona Intranet local, sites confiáveis, e Sites restritos na neste guia.
3.
Escolha a zona na qual o controle gerenciado Origem e clique no Custom Level botão. e Run ActiveX controls and plug-insScript ActiveX controls marked safe for scripting deve ser ativada para gerenciado controles ActiveX para executar ambos.
Consulte também
COMO: Solicitar Permissões Mínimas Usando o Sinalizador RequestMinimum O Sinalizador RequestMinimum, você pode solicitar um conjunto mínimo de permissões para executar seu código requer. Por outro lado, o RequestRefuse Sinalizador permite fazer recusar permissões, especificando quais seu código não deve ser concedido explicitamente. Ao contrário de usar o RequestMinimum Sinalizador, o aplicativo será executada se ele não receber todas as permissões que você solicitar usando o RequestOptional Sinalizador, e um SecurityException ser acionada quando seu aplicativo tenta acessar um recurso protegido se. Se você usar esse tipo de solicitação, você deve ativar o seu código para capturar quaisquer exceções serão que ser acionada se seu código não é concedido a permissão opcional. O exemplo a seguir solicita FileIOPermission usando o RequestMinimum Sinalizador. O exemplo não executará se ele não foi concedido a permissão solicitada. Este exemplo assume que existe em LogNameSpace Uma classe Log hipotético. A Log classe contém o MakeLog método que cria um novo arquivo de log no computador local. Este aplicativo cria uma nova instância da classe Log e executa o MakeLog método no bloco try. Usando a catch palavra-chave, ela intercepta qualquer SecurityException acionada e exibe uma mensagem. Exemplo C# //The request is placed at the assembly level. using System.Security.Permissions; [assembly:FileIOPermission(SecurityAction.RequestMinimum, Unrestricted = true)] namespace MyNamespace { using System; using System.Security; //The hypothetical class log is in this namespace. using LogNameSpace; public class MyClass { public MyClass() { } public static void Main(string[] args) { //Put any code that requires optional permissions in the try block. try { Log MyLog = new Log(); MyLog.MakeLog(); Console.WriteLine("The Log has been created."); } //Catch the security exception and inform the user that the //application was not granted FileIOPermission. catch(SecurityException) { Console.WriteLine("This application does not have permission to write to the disk."); } } } }
O código anterior cria o arquivo de log e exibirá a seguinte mensagem para o console se ele tiver permissões suficientes: The Log has been created.
Se o código é executado em um compartilhamento e as configurações de segurança local não permitem esse código para possui FileIOPermission, o código não é concedido permissão suficiente e exibirá a seguinte mensagem: This application does not have permission to write to the disk.
COMO: Criar Objetos GenericPrincipal e GenericIdentity Visual C# Consolidado
608
Você pode usar a GenericIdentity classe em conjunto com a GenericPrincipal classe para criar um esquema de autorização que existe independentes de um domínio Windows NT ou Windows 2000. Para criar um objeto GenericPrincipal 1.
Criar uma nova instância da classe identidade e inicializar-lo com o nome que você deseja que ele seja mantenha. O código a seguir cria um novo GenericIdentity objeto e inicializalo com o nome MyUser. C# GenericIdentity MyIdentity = new GenericIdentity("MyUser");
2.
Criar uma nova instância da classe GenericPrincipal e inicializar-lo com o objeto criado GenericIdentity anteriormente e uma matriz de seqüências de caracteres que representam as funções que você deseja associado a este objeto. O exemplo de código a seguir especifica uma matriz de seqüências de caracteres que representam uma função Administrador e uma função do usuário. O GenericPrincipal depois está inicializado com o anterior GenericIdentity e a matriz de seqüência. C# String[] MyStringArray = {"Manager", "Teller"}; GenericPrincipal MyPrincipal = new GenericPrincipal(MyIdentity, MyStringArray);
3.
Use o código a seguir para conectar o objeto para o segmento atual. Isso é importante em situações onde o principal deve ser validado várias vezes, ele deve ser validado pelo outros código em execução em seu aplicativo, ou ele deve ser validado por um PrincipalPermission objeto. Ainda poderá realizar validação baseada em função no objeto principal sem anexá-los para o segmento. Para obter mais informações, consulte Substituir um objeto principal. C# Thread.CurrentPrincipal = MyPrincipal;
Exemplo O exemplo de código a seguir demonstra como criar uma instância de um GenericPrincipal e um GenericIdentity. Este código exibe os valores um desses objetos para o console. C# using System; using System.Security.Principal; using System.Threading; public class Class1 { public static int Main(string[] args) { // Create generic identity. GenericIdentity MyIdentity = new GenericIdentity("MyIdentity"); // Create generic principal. String[] MyStringArray = {"Manager", "Teller"}; GenericPrincipal MyPrincipal = new GenericPrincipal(MyIdentity, MyStringArray); // Attach the principal to the current thread. // This is not required unless repeated validation must occur, // other code in your application must validate, or the // PrincipalPermisson object is used. Thread.CurrentPrincipal = MyPrincipal; // Print values to the console. String Name = MyPrincipal.Identity.Name; bool Auth = MyPrincipal.Identity.IsAuthenticated; bool IsInRole = MyPrincipal.IsInRole("Manager"); Console.WriteLine("The Name is: {0}", Name); Console.WriteLine("The IsAuthenticated is: {0}", Auth); Console.WriteLine("Is this a Manager? {0}", IsInRole); return 0; } }
Quando executado, o aplicativo exibirá uma saída semelhante à seguinte.
Visual C# Consolidado
609
The Name is: MyIdentity The IsAuthenticated is: True Is this a Manager? True
COMO: Criar um Objeto WindowsPrincipal Existem duas maneiras para criar um WindowsPrincipal objeto, dependendo se código repetidamente deve executar a validação baseada em função ou deve executar ele somente uma vez. Se código repetidamente deve executar validação baseada em função, o primeiro dos seguintes procedimentos produz menos sobrecarga. Quando código precisa para fazer validações baseada em função apenas uma vez, você pode criar um WindowsPrincipal objeto, usando o segundo dos procedimentos a seguir. Para criar um objeto WindowsPrincipal para validação repetidos 1.
Chame o SetPrincipalPolicy método no objeto AppDomain que é retornado pela propriedade estático System.AppDomain.CurrentDomain, passando o método um PrincipalPolicy valor de enumeração que indica qual a nova diretiva deve ser. Valores com suporte são NoPrincipal, UnauthenticatedPrincipal,. e WindowsPrincipal O código a seguir demonstra esse chamada de método. C# AppDomain.CurrentDomain.SetPrincipalPolicy( PrincipalPolicy.WindowsPrincipal);
2.
Com a diretiva definida, use a propriedade estático System.Threading.Thread.CurrentPrincipal para recuperar o objeto que encapsula o usuário Windows atual. Porque o tipo de retorno de propriedade é IPrincipal, você deve convertido o resultado para um WindowsPrincipal tipo. O código a seguir inicializa um novo WindowsPrincipal objeto com o valor do principal associado ao segmento atual. C# WindowsPrincipal MyPrincipal = (WindowsPrincipal) Thread.CurrentPrincipal;
Para criar um objeto WindowsPrincipal para um único validação 1.
Inicializar um novo WindowsIdentity objeto ao chamar o método estático System.Security.Principal.WindowsIdentity.GetCurrent, que consultas a conta do Windows atual e coloca informações sobre essa conta para o objeto identidade recém-criado. O código a seguir cria um novo WindowsIdentity objeto e inicializa-lo para o usuário autenticado atual. C# WindowsIdentity MyIdentity = WindowsIdentity.GetCurrent();
2.
Criar um novo WindowsPrincipal objeto e passar ele o valor do WindowsIdentity objeto criado na etapa anterior. C# WindowsPrincipal MyPrincipal = new WindowsPrincipal(MyIdentity);
3.
Quando o objeto principal foi criada, pode usar um dos vários métodos para validar-lo. Para obter mais informações, consulte Verificações de segurança baseada em função.
COMO: Executar Verificações de Segurança Imperativas Para uma demanda imprescindível, você pode chamar o Demand método do objeto PrincipalPermission para determinar se o objeto principal atual representa a identidade especificado, função, ou ambos. Supondo que um objeto corretamente construído
Visual C# Consolidado
610
PrincipalPermission chamado MyPrincipalPermission, uma demanda imprescindível pode ser chamado com o código a seguir. C# MyPrincipalPermission.Demand();
Exemplo O exemplo de código a seguir usa uma verificação imprescindível para garantir que um GenericPrincipal Correspondências o PrincipalPermission objeto. Uma verificação imprescindível é útil quando vários métodos ou outros conjuntos de módulos no domínio do aplicativo deve fazer determinations baseada em função. Enquanto este exemplo é extremamente simples, ele ilustra o comportamento associado a uma demanda baseada em função. C# using System; using System.Security.Permissions; using System.Security.Principal; using System.Security; using System.Threading; using System.Security.Cryptography; public class MainClass { public static int Main(string[] args) { Console.WriteLine("Enter '1' to use the proper identity or " + "any other character to use the improper identity."); if(Console.ReadLine() == "1") { // Create a generic identity. GenericIdentity MyIdentity = new GenericIdentity("MyUser"); // Create a generic principal. String[] MyString = {"Administrator", "User"}; GenericPrincipal MyPrincipal = new GenericPrincipal(MyIdentity, MyString); Thread.CurrentPrincipal = MyPrincipal; } PrivateInfo(); return 0; } public static void PrivateInfo() { try { // Create a PrincipalPermission object. PrincipalPermission MyPermission = new PrincipalPermission("MyUser", "Administrator"); // Demand this permission. MyPermission.Demand(); // Print secret data. Console.WriteLine( "\n\nYou have access to the private data!"); } catch(SecurityException e) { Console.WriteLine(e.Message); } } }
Se os tipos 1 de usuário, os objetos Principal e identidade necessários para acessar o PrivateInfo método são criados. Se o usuário digitar qualquer outro caractere, nenhum objeto principal e identidade são criados e uma exceção de segurança é acionada quando o PrivateInfo método é chamado. Se o segmento atual está associado a um objeto que tem o nome MyUser e a Administrator função, a seguinte mensagem será exibida. You have access to the private data!
Como: Recusar permissões usando o sinalizador RequestRefuse Se você estiver preocupado com que seu código pode ser usado para acessar recursos do sistema de forma mal-intencionada, você pode solicitar que ele nunca ser concedida uma permissão específica. Por exemplo, um aplicativo que navega dados em um arquivo mas nunca modifica os dados podem recusar quaisquer permissões de gravação arquivo. No caso de um erro ou um ataque malicioso, esse código não pode danificar os dados no qual ele funciona. Permite que RequestRefuse um grande conjunto de permissões para ser solicitado como opcional permissões, garantindo determinadas permissões específicas que não estão na concessão. O exemplo a seguir utiliza RequestRefuse para recusar FileIOPermission do sistema de segurança Runtime idioma comum: Exemplo C#
Visual C# Consolidado
611
//The request is placed at the assembly level. using System.Security.Permissions; [assembly:FileIOPermission(SecurityAction.RequestRefuse ,Unrestricted = true)] namespace MyNameSpace { using System; using System.Security; using System.Security.Permissions; using System.IO; public class MyClass { public MyClass() { } public static int Main(string[] args) { //Creation of the log is attempted in the try block. try { StreamWriter TextStream = new StreamWriter("Log.txt"); TextStream.WriteLine("This Log was created on {0}", DateTime.Now); TextStream.Close(); Console.WriteLine("The Log was created"); } //Catch the Security exception and inform the user that the //application was not granted FileIOPermission. catch(SecurityException) { Console.WriteLine("This application does not have permission to write to the disk."); } return 0; } } }
O exemplo anterior não recebeu permissão para criar o arquivo e gera uma exceção de segurança. A instrução catch intercepta a exceção e o aplicativo exibe a mensagem a seguir para o console: This application does not have permission to write to the disk.
COMO: Solicitar Permissão para Acessar Código Não-Gerenciado Você pode facilmente solicitar permissões pela aplicação Atributos que representam as permissões que você deseja solicitação para o nível Conjunto de seu código. Você usar os atributos podem variar, dependendo as permissões que você está solicitando. Solicitações são compilado no e avaliadas pelo tempo de execução quando seu código é carregado na memória durante a execução. do seu aplicativo é manifesto de conjunto de módulos (assembly) o Metadados O exemplo a seguir mostra como solicitar permissão para acessar código não gerenciado. Observe que ele usa um SecurityPermissionAttribute. e especifica dois valores), e um sinalizador que indica qual permissão é está sendo solicitado um SecurityAction valor que especifica o tipo de solicitação de permissão está sendo feita, no caso: (RequestMinimum Nesse caso, SecurityPermissionFlag.UnmanagedCode especifica uma solicitação de permissão de código não gerenciada. A assembly: sintaxe informa o compilador que o atributo está sendo aplicada no nível do conjunto. Exemplo C# //The request is placed at the assembly level. using System.Security.Permissions; [assembly:SecurityPermissionAttribute(SecurityAction.RequestMinimum, Flags = SecurityPermissionFlag.UnmanagedCode)] namespace MyNamespace { using System; using System.Runtime.InteropServices; public class MyClass { public MyClass() { } public void MyMethod() { //Perform interoperation with unmanaged code here. } } }
Se o código anterior não receber SecurityPermission com o UnmanagedCode Sinalizador, tempo de execução throws um PolicyException e o código não é permitido para executar. No entanto, se o código não receber essa permissão, então ele tem permissão para executar.
COMO: Solicitar Permissão para um Conjunto de Permissões Nomeadas Em vez de solicitar permissões individuais,. (), usando RequestMinimum, RequestOptional ou RequestRefuse Você pode solicitar os os seguintes conjuntos permissão interna, Execution, InternetFullTrust, LocalIntranet e SkipVerification: Nothing Não é possível solicitar personalizado chamado conjuntos de permissões ou a Everything permissão interna modificável
Visual C# Consolidado
612
definir porque eles representam as permissões pode variar. O exemplo a seguir mostra a sintaxe para solicitar permissão para um conjunto de permissões nomeado. Anexa com um Name valor que representa o nome da permissão desejado Definir. um PermissionSetAttribute Exemplo C# //The attribute is placed at the assembly level. using System.Security.Permissions; [assembly:PermissionSetAttribute(SecurityAction.RequestMinimum, Name = "FullTrust")] namespace MyNamespace { using System; using System.Runtime.InteropServices; public class MyClass { public MyClass() { } public void MyMethod() { //Perform operations that require permissions here. } } }
Como: Solicitar permissões opcionais usando o sinalizador RequestOptional O SecurityAction.RequestOptional Sinalizador, você pode solicitar um conjunto de permissões enquanto recusando todas as outras permissões o Runtime caso contrário pode ter sido disposto a fornecer. Por outro lado, o RequestRefuse Sinalizador permite fazer recusar permissões, especificando quais seu código não deve ser concedido explicitamente. Ao contrário de usar o RequestMinimum Sinalizador, o aplicativo será executada se ele não receber todas as permissões que você solicitar usando o RequestOptiona Sinalizador l, e um SecurityException ser acionada quando seu aplicativo tenta acessar um recurso protegido se. Se você usar esse tipo de solicitação, você deve ativar o seu código para capturar quaisquer exceções serão que ser acionada se seu código não é concedido a permissão opcional. As solicitações FileIOPermission exemplo a seguir usando o SecurityAction.RequestOptional Sinalizador, indiretamente recusando todas as outras permissões. Este exemplo assume que existe em LogNameSpace Uma classe Log hipotético. A Log classe contém o MakeLog método que cria um novo arquivo de log no computador local. Este aplicativo cria uma nova instância da classe Log e executa o MakeLog método no bloco try. Usando a catch palavra-chave, ela intercepta qualquer SecurityException acionada e exibe uma mensagem. Exemplo C# //The request is placed at the assembly level. using System.Security.Permissions; [assembly:FileIOPermission(SecurityAction.RequestOptional, Unrestricted = true)] namespace MyNamespace { using System; using System.Security; //The hypothetical class log is in this namespace. using LogNameSpace; public class MyClass { public MyClass() { } public static void Main(string[] args) { //Put any code that requires optional permissions in the try block. try { Log MyLog = new Log(); MyLog.MakeLog(); Console.WriteLine("The Log has been created."); } //Catch the security exception and inform the user that the //application was not granted FileIOPermission. catch(SecurityException) { Console.WriteLine("This application does not have permission to write to the disk."); } } } }
O código anterior cria o arquivo de log e exibirá a seguinte mensagem para o console se ele tiver permissões suficientes: The Log has been created.
Se o código é executado em um compartilhamento e as configurações de segurança local não permitem esse código para possui FileIOPermission, o código não é concedido permissão suficiente e exibirá a seguinte mensagem:
Visual C# Consolidado
613
This application does not have permission to write to the disk.
COMO: Armazenar Chaves Asssimétricas em um Contêiner de Chaves Assimétrica chaves particulares nunca devem ser armazenadas verbatim ou em texto sem formatação para o computador local. Se você precisará armazenar uma chave particular, você deve usar um contêiner de chave Para obter mais informações sobre recipientes chave, consulte a seção CryptoAPI na documentação do Platform SDK em http://msdn.microsoft.com. Para criar uma chave assimétrica e salvá-lo em um contêiner de chave 1.
Criar uma nova instância de uma CspParameters classe e passar o nome que você deseja que chamar o contêiner de chave para o CspParameters.KeyContainerName campo.
2.
Create a new instance of a class that derives from the AsymmetricAlgorithm class (usually RSACryptoServiceProvider or DSACryptoServiceProvider) and pass the previously created CspParameters object to its constructor.
Para excluir uma chave de uma contêiner de chave 1.
Criar uma nova instância de uma CspParameters classe e passar o nome que você deseja que chamar o contêiner de chave para o CspParameters.KeyContainerName campo.
2.
Criar uma nova instância de uma classe que deriva da classe AsymmetricAlgorithm (. ou DSACryptoServiceProvider) e passar o objeto anteriormente criado CspParameters para seu construtor geralmente RSACryptoServiceProvider
3.
Definir a PersistKeyInCSP propriedade de classe que deriva de AsymmetricAlgorithm para false (False no Visual Basic.)
4.
Chame o Clear método da classe que deriva de AsymmetricAlgorithm. Esse método libera todos os recursos da classe e limpa o contêiner de chave.
Exemplo O exemplo a seguir demonstra como criar uma chave assimétrica, salvá-lo em um contêiner de chave, recuperar a chave em uma hora posterior e excluir a chave do contêiner. Observe que que código no método GenKey_SaveInContainer e o GetKeyFromContainer método é semelhante. Quando você especificar um nome contêiner de chave para um CspParameters objeto e transmiti-las a um AsymmetricAlgorithm objeto com a PersistKeyInCsp propriedade ou PersistKeyInCsp propriedade definida como true, ocorre o seguinte. Se um contêiner de chave com o nome especificado não existir, então um é criado e a chave é persistente. Se um contêiner de chave com o nome especificado não existir, então a chave no contêiner automaticamente é carregado no objeto atual AsymmetricAlgorithm. Portanto, o código no método GenKey_SaveInContainer persiste a chave porque ele é executado primeiro, enquanto o código no método GetKeyFromContainer carrega a chave porque ele é executado segundo. C# using System; using System.IO; using System.Security.Cryptography; public class StoreKey { public static void Main() { try { // Create a key and save it in a container. GenKey_SaveInContainer("MyKeyContainer"); // Retrieve the key from the container. GetKeyFromContainer("MyKeyContainer"); // Delete the key from the container. DeleteKeyFromContainer("MyKeyContainer"); // Create a key and save it in a container. GenKey_SaveInContainer("MyKeyContainer"); // Delete the key from the container. DeleteKeyFromContainer("MyKeyContainer"); } catch(CryptographicException e) { Console.WriteLine(e.Message); } } public static void GenKey_SaveInContainer(string ContainerName) { // Create the CspParameters object and set the key container // name used to store the RSA key pair.
Visual C# Consolidado
614
CspParameters cp = new CspParameters(); cp.KeyContainerName = ContainerName; // Create a new instance of RSACryptoServiceProvider that accesses // the key container MyKeyContainerName. RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(cp); // Display the key information to the console. Console.WriteLine("Key added to container: \n {0}", rsa.ToXmlString(true)); } public static void GetKeyFromContainer(string ContainerName) { // Create the CspParameters object and set the key container // name used to store the RSA key pair. CspParameters cp = new CspParameters(); cp.KeyContainerName = ContainerName; // Create a new instance of RSACryptoServiceProvider that accesses // the key container MyKeyContainerName. RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(cp); // Display the key information to the console. Console.WriteLine("Key retrieved from container : \n {0}", rsa.ToXmlString(true)); } public static void DeleteKeyFromContainer(string ContainerName) { // Create the CspParameters object and set the key container // name used to store the RSA key pair. CspParameters cp = new CspParameters(); cp.KeyContainerName = ContainerName; // Create a new instance of RSACryptoServiceProvider that accesses // the key container. RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(cp); // Delete the key entry in the container. rsa.PersistKeyInCsp = false; // Call Clear to release resources and delete the key from the container. rsa.Clear(); Console.WriteLine("Key deleted."); } }
Saída Key added to container: Key Information A Key retrieved from container : Key Information A Key deleted. Key added to container: Key Information B Key deleted.
COMO: Adicionar Assemblies à Política de Segurança usando Caspol.exe Um conjunto que implementa uma permissão personalizada, ou implementa qualquer outro objeto de segurança personalizado que não está incluído no .NET Framework, deve ser adicionado à lista do conjunto totalmente confiável. Você pode fazer isso usando o Ferramenta Diretiva de segurança para acesso de código (Caspol.exe). Não é uma lista separada para cada nível de diretiva. A lista do conjunto totalmente confiável concede seus membros para o nível de diretiva relacionadas confiança total. Isso é necessário para manter o Runtime de executar resoluções da diretiva circular. Para adicionar um conjunto que implementa um objeto de segurança personalizados para a lista do conjunto totalmente confiável 1.
2.
Antes de adicionar um conjunto a diretiva de segurança, você deve dar-lhe um nome de alta segurança e colocá-lo no cache de conjunto global Para obter mais informações sobre como trabalhar com conjuntos e o cache de conjunto de módulos global, consulte Criando e usando conjuntos Named STRONG-. Digite o seguinte comando no prompt de comando: [caspol -enterprise | -user | -machine] addfulltrust – AssemblyFile Especificar a opção Nível diretiva antes da –addfulltrust opção.Se você omitir a opção Nível de diretiva, listas Caspol.exe a permissão define como o nível de diretiva padrão. Para administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de diretiva de usuário. O comando a seguir adiciona MyCustomPermissionSet.exe à lista o nível de diretiva de usuário na montagem totalmente confiável. caspol –user –addfulltrust MyCustomPermissionSet.exe
Visual C# Consolidado
615
3.
Se você adicionar o conjunto depende do outro conjunto você também deve incluir esse conjunto para a lista. (ou seja, usa tipos implementados em outro conjunto),
Adicionar um conjunto a uma lista do conjunto totalmente confiável não não garante que ele irá receber confiança total pelo sistema da diretiva como um todo, mas apenas que ele irá receber confiança total no nível de diretiva onde ele estiver listado. Por exemplo, se você incluir o conjunto MyCustomPermission.exe para o nível de diretiva de usuário é totalmente confiável Lista do conjunto, mas MyCustomPermission.exe recebe direitos de execução apenas de diretiva da máquina, MyCustomPermission.exe eventualmente seria concedida apenas direitos de execução. Portanto, é importante lembrar que colocar um conjunto na lista do conjunto totalmente confiável somente ajuda evite criar resoluções da diretiva circular para o nível de diretiva onde ele estiver listado. Isso não garante que o conjunto realmente implementar a permissão personalizada recebe uma concessão confiança total.
COMO: Exibir Grupos de Código Utilizando Caspol.exe Do Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) você pode usar para exibir uma lista simples de grupos de código pertencentes a um nível de diretiva, ou uma lista que inclui os nomes e descrições dos grupos de código. Para listar o código grupos para um nível de diretiva •
Digite o seguinte comando no prompt de comando: [caspol -enterprise | -all | -machine | -user] listgroups – Especificar a opção Nível diretiva antes da –listgroups opção.Se você omitir a opção Nível de diretiva, Caspol.exe listará os grupos de códigos no nível de diretiva padrão. Para administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de diretiva de usuário. O comando a seguir lista os grupos de códigos no nível de diretiva do usuário. caspol –user -listgroups
Para listar os nomes de grupo de código e descrições de um nível de diretiva •
Digite o seguinte comando no prompt de comando: [caspol -enterprise | -all | -machine | -user] listdescription – Se você omitir a opção Nível de diretiva, Caspol.exe listará os grupos de códigos no nível padrão. O comando a seguir lista os grupos de códigos e as descrições para todos os níveis de diretiva (Empresa, Máquina e Usuário). caspol –all –listdescription
COMO: Modificar Permissões em um Conjunto de Permissões Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para modificar uma permissão em um conjunto de permissão. Observação O.NET Framework inclui diversos conjuntos de permissão interna. O conjunto de permissões somente internos que pode ser alterado é o Everything conjunto de permissão. Para modificar uma permissão em uma permissão definido usando Mscorcfg.msc
Visual C# Consolidado
616
1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando: o
Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc.
o
2.
Expanda o Runtime Security Policy nó.
3.
Expanda o nó para o nível de diretiva você deseja alterar a permissão para.
4.
Expanda o Permission Sets nó.
5.
Clique com o botão direito do mouse no conjunto de permissão cuja permissão você deseja modificar e escolha Change Permissions.
6.
Selecione uma permissão a partir da Assigned Permissions lista e clique em Properties. A Permission Settings caixa de diálogo será exibida, que contém informações sobre a permissão selecionada. Altere as informações para essa permissão e clique em OK.
7.
Clique em Finish.
COMO: Adicionar Permissões a um Conjunto de Permissões Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para adicionar uma permissão a um conjunto de permissão. Observação O.NET Framework inclui diversos conjuntos de permissão interna. O conjunto de permissões somente internos que pode ser alterado é o Everything conjunto de permissão. Para adicionar uma permissão a uma permissão definido usando Mscorcfg.msc 1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando: o o
2. 3. 4.
Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc. Expanda o Runtime Security Policy nó. Expanda o nó para o nível de diretiva que contém o conjunto de permissão você deseja adicionar a permissão para. Expanda o Permission Sets nó.
5.
Clique com o botão direito do mouse no conjunto de permissão você deseja adicionar a permissão para e escolha Change Permissions.
6.
Selecione uma permissão a partir da Available Permissions lista e clique em Add. A Permission Settings caixa de diálogo será exibida, que contém informações sobre a permissão selecionada. Digite as informações necessárias para essa permissão e clique em OK.
Visual C# Consolidado
617
Se você desejar adicionar uma permissão personalizada, clique no Import botão e navegue até o arquivo XML que contém informações sobre a permissão personalizada. 7.
Quando você tiver terminado adicionar permissões, clique em Finish.
COMO: Suprimir Avisos de Alteração de Política Usando Caspol.exe Do Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) sempre que você usa uma opção que altera a diretiva de segurança, avisa sobre a alteração de diretiva específico que está prestes a ocorrer. Se você estiver familiarizado com Caspol.exe e considere desses avisos desnecessários, você pode desativá-los. Para suprimir avisos alterar da diretiva Digite o seguinte comando no prompt de comando:
•
caspol –polchgprompt off
Para ativar diretiva alterar avisos Digite o seguinte comando no prompt de comando:
•
caspol –polchgprompt on
Antes como desativar este recurso, considere que geralmente é muito mais fáceis de serem confirmar uma alteração de diretiva. antes que ele é para corrigir a diretiva posteriormente
COMO: Alterar Condições de Participação em um Grupo de Código Você pode usar a ferramenta .NET Framework Configuration (Mscorcfg.msc) para alterar condições de membro em relação a grupos de códigos. Para alterar para um grupo de códigos usando Mscorcfg.msc condições de membro 1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando: o o
2. 3. 4. 5. 6. 7.
Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc. Expanda o Runtime Security Policy nó. Expanda o nó para o nível de diretiva que contém o grupo de código que você deseja modificar. Expanda o Code Groups nó e expanda árvore sob o All_code nó. Clique com o botão direito do mouse no grupo de código adequada e selecione Properties. Clique na Membership Condition guia. Selecione a condição de membros você deseja associar ao grupo de códigos na caixa de listagem drop-down. Em seguida, siga as instruções para digitar as informações necessárias para a condição de membro e clique em OK. Se você deseja importar uma condição de membro de um arquivo XML, selecione (custom) na lista drop-down condição de participação. Clique Import e navegue até o arquivo XML.
Visual C# Consolidado
618
COMO: Exibir Grupos de Código e Conjuntos de Permissões Usando Caspol.exe Configurações de segurança indesejado se algumas vezes, aplicam a um conjunto porque ele por engano pertence ou não pertence a algum grupo de códigos. Esses efeitos colaterais pode ocorrer quando os grupos de códigos são adicionadas ou excluídas de níveis de diretiva. Do Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) para facilitar ainda mais a localizar esses problemas no código os níveis de diretiva ' hierarquias de grupo, você pode usar para listar todos os grupos de código pertence a um conjunto. O conjunto é concedido um conjunto de permissões por cada nível de diretiva. O conjunto de permissões efetivas que a diretiva de segurança concede ao código é determinado pela interseção das conjuntos de permissões concedidas pelas diretivas máquina e usuário. Você pode usar Caspol.exe para exibir conjunto concedido a um conjunto de permissões por um nível de diretiva específico. Você pode usar Caspol.exe para exibir o conjunto de permissões que resulta da interseção do conjunto de permissão concedido pelas diretivas máquina e usuário. Para listar os grupos de códigos um conjunto pertence a •
Digite o seguinte comando no prompt de comando: [caspol -enterprise | -all | -machine | -user] resolvegroup – assembly-file Especificar a opção Nível diretiva antes da –resolvegroup opção.Se você omitir a opção Nível de diretiva, Caspol.exe mostra todos os níveis de diretiva. O comando a seguir lista os grupos de códigos que MyAssembly.dll pertença no nível de diretiva do usuário.
caspol – resolvegroup do usuário – MyAssembly.dll
Para listar a permissão definir para um conjunto •
Digite o seguinte comando no prompt de comando: caspol [-enterprise|-machine|-user|-all] –resolveperm assembly-file Especificar a opção Nível diretiva antes da –resolveperm opção.Se você omitir a opção Nível de diretiva, Caspol.exe mostra a interseção de todos os níveis de diretiva. O comando a seguir solicita uma lista de permissões que se aplicam a MyApplication.exe no nível de diretiva do usuário. caspol –user –resolveperm MyApplication.exe
Como: Administrar a política de segurança para usuários não padrão usando Caspol.exe Do Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) você pode usar para administrar uma diretiva de usuário para um usuário que não seja o usuário atual. Para administrar diretiva de usuário para um usuário que não seja o usuário atual •
Use the -customuser path option instead of the –user policy-level option. The –customuser option points Caspol.exe to a specified user security configuration file. Note that –customuser must be followed by the path to the user security configuration file. O comando a seguir lista os grupos de códigos no usuário arquivo de configuração de diretiva de segurança localizado em C:\config_test\. caspol –customuser "C:\config_test\security.config" –listgroups
Visual C# Consolidado
619
Quando você especifica a –all opção antes da opção Nível de diretiva para listar ou resolver Diretiva, Caspol.exe considera todos os níveis de diretiva (usuário, máquina, e empresa).A -all opção sempre usa a diretiva para o usuário atual. No entanto, você pode usar a diretiva para outro usuário em uma lista de todos os níveis de diretiva ou uma resolução da diretiva em níveis de diretiva.
Para listar ou resolver toda a diretiva níveis para um usuário que não seja o usuário atual Use a -customall path opção em vez da opção -all.
•
O seguinte comando resolve diretiva contra a empresa atual e diretiva da máquina,, bem como contra uma diretiva de usuário personalizada. caspol –customall "c:\config_test\security.config" –resolvegroup "myApplication.exe"
COMO: Alterar Conjuntos de Permissão Associados com um Grupo de Código Existente Você pode usar a ferramenta .NET Framework Configuration (Mscorcfg.msc) para alterar os conjuntos de permissões associados a um grupo de códigos. Para alterar permissão conjuntos associado a um grupo de códigos existentes usando Mscorcfg.msc 1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando: o o
Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc.
2.
Expanda o Runtime Security Policy nó.
3.
Expanda o nó para o nível de diretiva que contém o grupo de código que deseja modificar.
4.
Expanda o Code Groups nó e expanda árvore sob o All_code nó.
5. 6. 7.
Clique com o botão direito do mouse no grupo de código adequada e selecione Properties. Clique na Permission Set guia. Selecione a permissão conjunto você deseja associar ao grupo de códigos na lista dropdown e clique em OK.
COMO: Analisar Problemas com Permissões de Assembly Usando Caspol.exe Você pode usar para solucionar problemas que podem causar um conjunto para não executar ou para acessar recursos protegidos ou executado quando não deveria. o Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) Para analisar problemas com um conjunto que não é executado 1.
Use the –all and the –resolveperm options to determine the permissions that policy grants to the assembly: caspol –all –resolveperm assembly-file Determinar se o conjunto tem o direito de executar, verificando se o sinalizador de execução está definido na classe SecurityPermission. Se o conjunto possui direitos de
Visual C# Consolidado
620
execução, o conjunto de permissões de segurança será ser irrestrito, ou o atributo sinalizadores irão incluir o sinalizador de execução. Se o conjunto deve acessar um recurso protegido, (por exemplo, para acessar um disco, criar janelas, gravação para o registro, e assim por diante), verifique se as permissões apropriadas estão definidas. 2.
Como as permissões concedidas pelos níveis de diretiva Empresa, Máquina, e usuário interseção, uma permissão deve ser definida em todos os níveis de um conjunto para recebê-lo. Se o conjunto não possui permissões suficientes, verifique as permissões concedidas ao conjunto em cada nível de diretiva: caspol –enterprise –resolveperm assembly-file caspol –machine –resolveperm assembly-file caspol –user –resolveperm assembly-file
3.
Se o conjunto for parte de um grupo de códigos cuja condição de membro é muito restritiva, ou definido cuja permissão associado não contém as permissões necessárias para o conjunto à função, o conjunto não pode ser executado corretamente. Se as permissões concedidas ao código são insuficientes, você pode criar um novo grupo de códigos que concede o conjunto as permissões necessárias Você também pode modificar o conjunto de permissões associado de ou a condição de membro de um dos grupos de códigos existentes para que o conjunto recebe as permissões apropriadas. Para obter mais informações sobre como fazer isso, consulte Como alterar grupos de códigos usando Caspol.exe:.
Para analisar um conjunto que acessa recursos protegidos ou é executada quando não deveria •
Se um conjunto é executado mas não, Deve ou se acessar recursos que ele não deve acessar (tais como recursos necessários para criar caixas de diálogo), um conjunto o conjunto provavelmente tem sido receber permissões muitos. Use the –resolveperm option to determine which permissions the assembly has been granted. Then use the –resolvegroups option to determine which code groups it belongs to. Alterar as condições de participação ou os conjuntos dos grupos de códigos associados para limitar as permissões concedidas ao conjunto de permissões associado.
COMO: Exibir Conjuntos de Permissão Usando Caspol.exe Do Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) você pode usar para listar a permissão define pertencentes para todos os níveis de diretiva ou para um nível única diretiva. Para exibir a permissão conjuntos usados em um nível de diretiva •
Digite o seguinte comando no prompt de comando: [caspol-enterprise | -all | -machine | -user] -listpset Especificar a opção Nível diretiva antes da –listpset opção.Se você omitir a opção Nível de diretiva, listas Caspol.exe a permissão define para o nível de diretiva padrão. Para administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de diretiva de usuário. O comando a seguir lista os conjuntos de permissão para todos os níveis de diretiva três. caspol –all -listpset
COMO: Desfazer Alterações de Política Usando Caspol.exe
Visual C# Consolidado
621
Se uma alteração de diretiva tem indesejados efeitos colaterais ou se acidentalmente a alteração foi feita no nível da Diretiva de segurança errado para recuperar a última diretiva Máquina, Usuário ou empresa antes que a alteração foi feita. No diretiva nível do computador em vez do nível de diretiva de usuário), como você pode usar (o Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) Para desfazer uma alteração de diretiva •
Digite o seguinte comando no prompt de comando: [caspol -enterprise | -all | -machine | -user] –recover Especificar a opção Nível diretiva antes da –recover opção.Se você omitir a opção Nível de diretiva, Caspol.exe desfaz a alteração de diretiva no nível de diretiva padrão. Para administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de diretiva de usuário. O seguinte comando desfaz a última alteração para a diretiva de usuário. caspol –user -recover
Observação A –recover opção somente desfaz a última alteração.Caspol.exe não não cache quaisquer alterações feitas a última alteração antes. Se você chamar essa opção duas vezes, você desfazer a recuperação da diretiva.
COMO: Importar uma Permissão Usando um Arquivo XML Um aplicativo talvez precise controlar o acesso a um recurso em uma maneira através de que não haja suporte pelas permissões fornecidos com o SDK do .NET Framework. Por exemplo, um aplicativo pode usar os registros de pessoal onde cada registro de funcionário é armazenado em um arquivo separado;, nesse caso, acesso Leitura e Gravação deve ser controlado independentemente em diferentes tipos de dados Funcionários. O desenvolvedor de aplicativos deve fornecer uma classe de permissão que permite que o aplicativo para que esse nível de detalhes de acesso para um arquivo. Exemplo O exemplo a seguir mostra como as informações para uma permissão podem exibidas no arquivo XML.
O elemento, class atributo, e version Atributo são presente para cada permissão no arquivo XML. O class atributo aponta para a classe e conjunto que implementam a permissão personalizada. A seqüência valor para este atributo pode estar em qualquer formato discutido no Especificando tipo nomes totalmente qualificados, mas será provavelmente estar no formato mostrado no exemplo. A marca pode conter outros atributos ou elementos filho definidos pelo desenvolvedor que descrevem o estado da permissão. No exemplo anterior, o Unrestricted atributo é definido pela classe CustomPermission.
Visual C# Consolidado
622
A nova permissão deve ir em um conjunto de permissões. Você pode usar para colocar a permissão em um dos conjuntos de permissão mutáveis ou para criar uma nova permissão definida. o Ferramenta .NET Framework Configuration (Mscorcfg.msc) Cuidado Antes de adicionar a permissão a diretiva de segurança, você talvez precise alterar o arquivo XML para que o estado da permissão atenda às suas necessidades. Consulte a documentação do aplicativo para saber sobre os atributos específicos para a permissão e como alterar seu estado. Cada grupo de código que está associado ao conjunto de permissões modificado concederá a nova permissão para código que é um membro do grupo do código. Para saber como adicionar uma permissão personalizada a um conjunto de permissões, consulte Configurar conjuntos de permissões usando a ferramenta Configuração .NET Framework.
COMO: Voltar para as Configurações de Política de Segurança Padrão Usando Caspol.exe Ocasionalmente, talvez seja necessário para redefinir uma diretiva de segurança para os padrões após algumas alterações da diretiva criar efeitos colaterais indesejáveis. A diretiva de segurança padrão fornece segurança adequada para seu computador em maioria das situações. Para retornar para as configurações Diretiva de segurança padrão •
Digite o seguinte comando no prompt de comando: [caspol -enterprise | -all | -machine | -user] –reset Especificar a opção Nível diretiva antes da –reset opção.Se você omitir a opção Nível de diretiva, a Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) retorna as configurações Diretiva de segurança padrão no nível de diretiva padrão. Para administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de diretiva de usuário. O comando a seguir redefine a diretiva Máquina. caspol –machine –reset
Observação Você pode desfazer a redefinição usando a –recover opção se nenhuma alteração de diretiva forem feitas após a –reset chamada.
COMO: Adicionar Grupos de Código Usando Caspol.exe Sample Group Addition Commands When you use the Code Access Security Policy tool (Caspol.exe) to add a code group to a code group hierarchy, you must define both a membership condition and a permission set for the new code group. You must also define the label or name of the parent code group in which you are adding the new code group. Optionally, you can also set other flags on the code group. For more information about these flags, see Code Access Security Policy Tool (Caspol.exe). To add a code group to a code group hierarchy •
Type the following command at the command prompt:
Visual C# Consolidado
623
caspol [-enterprise|-machine|-user] -addgroup {parentLabel|parentName} mship pset_name [-exclusive {on|off}][-levelfinal {on|off}] [-name name] [-description description text] Specify the policy-level option before the –addgroup option. If you omit the policy-level option, Caspol.exe adds the code group to the default policy level. For computer administrators, the default level is the machine policy level; for others, it is the user policy level. In this command: o
The parentLabel argument is the label of the parent code group for the new code group. Alternatively, you can use the parent's code group name (parentName) instead of the parentLabel. To obtain this information, list the code groups as described in How to: View Code Groups Using Caspol.exe.
o
The pset_name argument is the name of the permission set to associate with the new code group. Before a named permission set can be associated with a code group, it must be known at the policy level where you are adding the new code group. For example, if you want to associate a MyPset permission set with a new code group in the user policy, you must have already added the MyPset permission set to the user policy. The only time a permission set does not need to be added beforehand is when you use one of the standard permission sets provided by the .NET Framework. To learn how to add a permission set to a policy level, see How to: Add Permission Sets Using Caspol.exe.
o
The mship argument is the membership condition for the new code group. For the list of values for the mship argument, see Code Access Security Policy Tool (Caspol.exe). Observação
You cannot use the –addgroup option to add a code group to more than one level at a time. Each such addition must be made separately because different code group labels and the availability of certain permission sets can cause confusion. Sample Group Addition Commands The following procedures describe how to perform some of the most common code group addition tasks.
To add a code group that targets code from the intranet •
Use the -zone option, and specify Intranet as the membership value. The following command associates the Everything permission set with code from the intranet. The code group is also given the name Intranet_CG. You can use this name to refer to the newly created code group, rather than using its numeric labels. caspol –addgroup 1.1. –zone Intranet Everything –name "Intranet_CG"
To add a code group that targets code from the Internet Explorer Trusted sites •
Use the –zone option, and specify Trusted as the membership value. The following command associates the LocalIntranet permission set with code from the trusted zone and inserts the new code group as a child of the root of the code group hierarchy. caspol -addgroup All_Code -zone Trusted LocalIntranet
To add a code group that targets a specific software publisher •
Use the –pub option, and specify a certificate file, a signed file, or the hexadecimal representation of an X.509 certificate.
Visual C# Consolidado
624
Files from a software publisher must be signed appropriately for this membership condition to work. The membership condition can be constructed on the basis of either an actual certificate file or a signed .exe file. Suppose the certificate file for FourthCoffee (FourthCoffee.cer) is available. The following command adds a code group in the machine policy for code published by FourthCoffee and associates the Nothing permission set with the new group. The code group is added as a child code group of the root. caspol –machine –addgroup 1 –pub –cert FourthCoffee.cer Nothing
To add a code group that targets code from a particular Web site •
Use the –site option, and specify the URL of the Web site. Observação Due to the possibility of DNS name spoofing, using a Web site as a membership condition is not an effective way to ascertain the identity of code. Where possible, use a strong name membership condition, publisher membership condition, or the hash membership condition.
•
The following command associates the Intranet permission set with code from www.microsoft.com.
To add a code group that targets code from a particular URL •
Use the –url option, and specify the URL of the site. The URL must include a protocol, such as http://, http://, or ftp://. Additionally, a wildcard character (*) can be used to specify multiple assemblies from a particular URL. Observação Because a URL can be identified using multiple names, using a URL as a membership condition is not a safe way to ascertain the identity of code. Where possible, use a strong name membership condition, a publisher membership condition, or the hash membership condition. caspol –user –addgroup 1 –url http://www.contoso.com/bin/* FullTrust caspol –user –addgroup 1 –url http://www.contoso.com/bin/MyAssembly.dll FullTrust
To add a code group that overrides other permissions at a policy level •
Set the –exclusive flag for the new code group. The following command adds a code group under the Intranet_cg code group. The new code group grants the Everything permission set if the zone is trusted, overriding any other permissions that other code groups might grant. caspol –addgroup "Intranet_cg" –zone Trusted Everything –exclusive on
To add a code group with a custom membership condition •
Use the –custom option, and specify an XML file that contains the XML serialization of the custom membership condition.
Visual C# Consolidado
625
Caspol.exe supports the use of custom membership conditions in policy, which makes the policy system highly extensible. The following command adds a new code group to the root of the user policy. This new code group contains a custom membership condition found in the NewMembershipCondition.xml file and grants full trust to assemblies matching this membership condition. caspol –user –addgroup All_Code –custom NewMembershipCondition.xml FullTrust
To add a code group with a name and description 1. 2.
Use the –name option, and specify a name for the code group. Double quotes (" ") are required around names that contain spaces. Use the –description option, and specify a description for the code group.
You can use the name later to refer to a code group. The name provides better support than numeric labels for scripting policy changes. Default policy is shipped with default names. If not explicitly changed by an administrator, the default names make it easy for administrators using Caspol.exe to access specific code groups across policies and computers. The following command adds a code group under the All_Code group in the machine policy. The new code group checks for a FourthCoffee strong name (as found on Signed.exe) and grants FullTrust to all code that is so signed. The code group is named FouthCoffeeStrongName and is given an appropriate description. caspol –machine –addgroup All_Code –strong –file signed.exe FullTrust –name FouthCoffeeStrongName – description "Code group granting trust to code signed by FourthCoffee"
Observação If the same name is present in more than one code group, Caspol.exe resolves to the first code group it can find with the given name. It searches all the child code groups of a code group before searching sibling groups.
COMO: Substituir o Mecanismo de Auto-Proteção do Caspol.exe O Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) contém um mecanismo Self-Protection que impede alterações de diretiva de segurança que causaria-lo para cessar funcionando. Você pode substituir esse mecanismo Self-Protection, se necessário. Por exemplo, um administrador talvez precise substituir o mecanismo Self-Protection para atualizar a segurança, mesmo que Caspol.exe pode não funcionar corretamente posteriormente. Para substituir o mecanismo Self-Protection Caspol.exe •
Use a –force opção para a diretiva Alterar opção que caso contrário, ser rejeitada pelo Caspol.exe. O comando a seguir altera grupo de código raiz a diretiva Usuário é para associá-lo ao Nothing conjunto de permissões. caspol –force –user –chggroup 1 Nothing
Cuidado
Visual C# Consolidado
626
Use esta opção somente com extrema cautela. Ele poderá causar Caspol.exe para falhar ou cessar funcionando, nesse caso, a –recover opção não pode ser aplicada porque Caspol.exe não pode ser executado. Observação Se isso ocorrer, você pode executar o equivalente de uma –recover operação manual.A máquina submetidos a backup e diretiva de usuário são gravadas em arquivos Security.CFG.old. Simplesmente excluir o arquivo Security.cfg em onde você fez a alteração, o nível de diretiva e renomear o arquivo Security.CFG.old para Security.CFG. Para obter mais informações sobre onde esses arquivos estão localizados, consulte Arquivos de configuração de segurança.
COMO: Criar Grupos de Código Quando você cria um grupo de códigos usando a ferramenta .NET Framework Configuration (Mscorcfg.msc), você também deve associar o grupo com uma condição de membro e um conjunto de permissões. Para criar código grupos usando Mscorcfg.msc 1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando: o
Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc.
o
2.
Expanda o Runtime Security Policy nó.
3.
Expanda o nó para o nível de diretiva você deseja adicionar o grupo de códigos para.
4.
Expanda o Code Groups nó e expanda árvore sob o All_code nó.
5. 6.
Clique com o botão direito do mouse no grupo de código que será o pai imediato do novo grupo de códigos, e escolha New. Dê ao grupo de código um nome e, opcionalmente, uma descrição. Clique em Next.
7.
Selecione uma condição de membro na caixa drop-down. Siga as instruções para inserir as informações solicitadas para a condição de membro. Clique em Next.
8.
Escolha um conjunto de permissões existente a partir da caixa drop-down ou selecione Create a new permission set. Clique em Next e, clique em Finish.
COMO: Desativar a Coleta de Lixo Concorrente O Common Language Runtime (CLR) ou pode executar coleta de lixo simultaneamente em um segmento separado ou no mesmo segmento como o aplicativo. Use o < gcConcurrent > elemento para especificar como o Runtime deve ser executado coleta de lixo. A seguir mostra para desativar coleta de lixo simultâneas. Exemplo
Visual C# Consolidado
627
Por padrão, o tempo de execução executa coleta de lixo simultaneamente, que reduz o desempenho. Se seu aplicativo é segmento único e envolve interação usuário intensivo, deixe coleta de lixo simultâneas ativada para o aplicativo não faz pausa para executar coleta de lixo. Se seu aplicativo tem um aplicativo do servidor ASP.NET, não é preciso alterar o valor padrão de elemento .
COMO: Importar um Grupo de Código Usando um Arquivo XML Um aplicativo pode exigir que você adicionar um grupo código específico do aplicativo à diretiva de segurança. O aplicativo pode fornecidos com um conjunto que implementa o novo grupo de códigos e um arquivo XML que contém um serialização do novo grupo de códigos. O arquivo XML pode ser importado para diretiva de segurança usando o Ferramenta .NET Framework Configuration (Mscorcfg.msc). O arquivo XML também pode conter informações sobre participação o conjunto condição e permissões associada ao grupo de códigos. Normalmente, o aplicativo atender à condição de participação especificado e precisa definir a permissão associada. O exemplo a seguir mostra como informações para um grupo de códigos e seu conjunto condição e permissão de membros associados podem exibidas em um arquivo XML. Exemplo
O elemento contém informações para um novo grupo de códigos. O class e version atributos são necessários para o elemento. O class atributo aponta para a classe e conjunto que implementa o novo grupo de códigos. Valor do class atributo pode ser em qualquer formato discutido no Especificando tipo nomes totalmente qualificados, mas geralmente será estar no formato mostrado no exemplo. Para esta versão do .NET Framework, o version atributo é " 1 ". O Name e Description atributos pode ser qualquer seqüência válida e pode ser editado. O Name atributo é o nome da permissão definido como ele aparece na ferramenta .NET Framework Configuration. O elemento contém atributos ou elementos filho que especificam a condição que conjuntos devem atender para se tornar um membro do grupo do código e receber suas permissões associadas. O class atributo para está no mesmo formato que o class atributo para . Se um elemento contém um elemento e uma elemento , participação o conjunto condição e Permissão são associadas ao grupo de códigos automaticamente quando ele é importado. Do Ferramenta .NET Framework Configuration (Mscorcfg.msc) se uma desses elementos estiverem faltando, você deverá usar para associar o item ausente com o novo grupo de códigos. Para obter detalhes, consulte Configurar grupos de códigos usando a ferramenta Configuração .NET Framework.
COMO: Criar uma Política do Publisher
Visual C# Consolidado
628
Fornecedores de conjuntos podem estado que aplicativos devem usar uma versão mais recente de um conjunto, incluindo um arquivo de diretiva do editor com o conjunto atualizado. O arquivo de diretivas do editor especifica redirecionamento do conjunto e configurações base de código, e usa o mesmo formato como um arquivo de configuração do aplicativo. O arquivo de diretivas do editor é compilado em um conjunto e inserido no cache de conjunto global. Há três etapas envolvidas ao criar uma diretiva do editor: 1.
Criar um arquivo de diretivas do editor.
2.
Cria um conjunto da diretiva do editor.
3.
Incluir o conjunto da diretiva do editor para o cache de conjunto de módulos global.
O esquema da diretiva do editor está descrita em Redirecionando versões assembly. O exemplo a seguir mostra um editor que redireciona uma versão do myAssembly para outro arquivo de diretiva.
Para saber como especificar uma base de código, consulte Especificar local um conjunto na. Criando o conjunto da diretiva Publisher Do Vinculador do conjunto (AL.exe) uso para criar o conjunto da diretiva do editor.
Para criar um conjunto da diretiva do editor •
Digite o seguinte comando no prompt de comando: al /link:publisherPolicyFile /out:publisherPolicyAssemblyFile /keyfile:keyPairFile Neste comando:
o o
O publisherPolicyFile argumento é o nome do arquivo de diretiva do editor. O publisherPolicyAssemblyFile argumento é o nome da montagem da diretiva do editor que resulta deste comando. O nome arquivo do conjunto deve seguir o formato: policy.majorNumber.minorNumber.mainAssemblyName.dll
o
O keyPairFile argumento é o nome do arquivo que contém o par de chaves. Você deverá assinar o conjunto e editor conjunto da Diretiva com o mesmo par de chaves. O seguinte comando cria um conjunto da diretiva do editor chamado policy.1.0.myAssembly a partir de um arquivo de diretiva do editor chamado pub.config, e atribui um nome de alta segurança ao conjunto usando o par de chaves no arquivo sgKey.snk. al /link:pub.config /out:policy.1.0.myAssembly.dll /keyfile:sgKey.snk
Adicionando o conjunto da diretiva Publisher no cache do conjunto de módulos (assembly) global Do Ferramenta Assembly Cache global (Gacutil.exe) uso para adicionar o conjunto da diretiva do editor a cache de conjunto global.
Para adicionar o conjunto da diretiva do editor a cache de conjunto global Visual C# Consolidado
629
•
Digite o seguinte comando no prompt de comando: gacutil /i publisherPolicyAssemblyFile O comando a seguir adiciona policy.1.0.myAssembly.dll a cache de conjunto global. gacutil /i policy.1.0.myAssembly.dll
COMO: Remover Grupos de Código Usando Caspol.exe Do Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) você pode usar para remover grupos de códigos das hierarquias de grupo de código. Quando você exclui um grupo de código que tenha grupos de códigos filho, você também excluir os grupos de códigos filho. Você não pode copiar parte de uma hierarquia de grupo de código para outra parte do grupo de códigos ou para outra hierarquia de grupo de código. Portanto, a exclusão de um grupo de código pai destrói qualquer comportamento de segurança que foi definido na sua hierarquia filho. Cuidado Como ele altamente pode afetar a segurança, tome cuidado extremos quando você exclui grupos de códigos. Para remover um grupo de códigos de uma hierarquia de grupo de código •
Digite o seguinte comando no prompt de comando: caspol [-enterprise|-machine|-user] –remgroup {label|name} Especificar a opção Nível diretiva antes da –remgroup opção.Se você omitir a opção Nível de diretiva, Caspol.exe removerá a hierarquia de grupo de códigos especificada do nível de diretiva padrão. Para administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de diretiva de usuário. O comando a seguir exclui o grupo de códigos rotulado 1.1.2.. caspol –remgroup 1.1.2.
O comando a seguir exclui o grupo de códigos chamado MyApp_CodeGroup. caspol –remgroup MyApp_CodeGroup
COMO: Criar um Modelo de Canal num Arquivo de Configuração O exemplo a seguir mostra como criar um modelo do canal em um arquivo de configuração. Exemplo
COMO: Alterar Conjuntos de Permissão Usando Caspol.exe Você pode alterar o conteúdo de uma permissão específica definida por importar um novo arquivo XML que contém um conjunto de permissões que substitui o conjunto de permissões original. O conjunto de permissões somente mutáveis fornecido pelo SDK do .NET Framework é o Everything conjunto de permissão. Do Ferramenta Diretiva de segurança para acesso de código
Visual C# Consolidado
630
(Caspol.exe) você pode usar para substituir a permissão original de disco com o novo conjunto especificado no arquivo XML. Para alterar uma permissão defina Digite o seguinte comando no prompt de comando:
•
caspol –chgpset pset_file pset_name. O comando a seguir altera a FilePset permissão definida na diretiva de usuário para o estado especificado no arquivo NewPset.xml. caspol –user –chgpset NewPset.xml FilePset
COMO: Remover Conjuntos de Permissão Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para remover um conjunto em um nível específico de permissões. Para remover uma permissão defina usando Mscorcfg.msc 1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando: o
No.NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc.
o
2.
Expanda o Runtime Security Policy nó.
3.
Expanda o nó para o nível de diretiva que deseja remover um conjunto de permissões.
4.
Expanda o Permission Sets nó.
5.
Clique com o botão direito do mouse no conjunto de permissão você deseja remover e escolha Delete. Observação Não é possível remover conjuntos de permissão interna ou conjuntos de permissões que estão associados a um grupo de códigos.
COMO: Criar Conjuntos de Permissão Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para criar uma permissão definido para uma determinada nível e associá-lo a um grupo de códigos nova ou existente. Para criar uma permissão conjunto usando Mscorcfg.msc 1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando:
Visual C# Consolidado
631
o
Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc.
o
2.
Expanda o Runtime Security Policy nó.
3.
Expanda o nó para o nível de diretiva você deseja adicionar uma permissão definida.
4.
Clique com o botão direito do mouse Permission Sets e escolha New.
5.
Dar o conjunto de permissões um nome e, opcionalmente, uma descrição. Clique em Next.
6.
Selecione uma permissão a partir da Available Permissions lista e clique em Add. A Permission Settings caixa de diálogo será exibida, que contém informações sobre a permissão selecionada. Digite as informações necessárias para essa permissão e clique em OK. Se você desejar adicionar uma permissão personalizada, clique no Import botão e navegue até o arquivo XML que contém informações sobre a permissão personalizada.
7. 8.
Repita a etapa seis até todas as permissões desejadas são adicionadas ao conjunto de permissões. Quando você tiver terminado adicionar permissões, clique em Finish.
COMO: Tornar Grupos de Código Exclusivos ou Nível Final Opcionalmente, usando a ferramenta .NET Framework Configuration (Mscorcfg.msc), você pode fazer um código exclusivo de grupo ou Nível final, como mostrado nas seguintes instruções. Para tornar código grupos exclusivo ou final usando Mscorcfg.msc 1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando: o
Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc.
o
2. 3. 4.
Expanda o Runtime Security Policy nó. Expanda o nó para o nível de diretiva que contém o grupo de código você deseja tornar exclusivo ou final. Expanda o Code Groups nó e expanda árvore sob o All_code nó.
5.
Clique com o botão direito do mouse no grupo de código que você deseja que seja exclusivo ou final e selecione Properties.
6.
Para fazer um grupo de códigos exclusivos, marque a caixa de seleção rotulada " Este nível de diretiva só terá a permissões do conjunto de permissões associado a este grupo de código ". OuPara fazer um nível de grupo de código final, marque a caixa de seleção rotulada " níveis de diretiva abaixo deste nível não serão avaliados ".
7.
Clique em OK.
COMO: Adicionar uma à lista de Política de Assemblies Visual C# Consolidado
632
Para o sistema de segurança para avaliar diretiva em um nível que tenha objetos de segurança que não são fornecidos com o SDK do .NET Framework, com êxito o conjunto deve ter confiança total no nível de diretiva. Do Ferramenta .NET Framework Configuration (Mscorcfg.msc) Quando você receber um conjunto que contém um novo componente de segurança, use para adicionar o conjunto à lista do conjunto totalmente confiável. Observação Colocar um conjunto na lista do conjunto totalmente confiável fornece confiança total ao conjunto somente no nível. Se o conjunto não estiver na lista de confiança total em todos os outros níveis, o conjunto não terá confiança total mas sim a interseção da qual é concedido por aqueles outros níveis. Para adicionar um conjunto à lista do conjunto totalmente confiável 1.
Em.NET Framework 1.0 e 1.1, na linha de comando, digite %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt de comando SDK no .NET Framework 2.0, inicie e tipo mscorcfg.msc. A interface de usuário para a ferramenta é exibida.
2.
Expanda o Runtime Security Policy nó.
3.
Expanda o nó para o nível de diretiva você deseja adicionar o novo conjunto para.
4.
Clique com o botão direito do mouse Policy Assemblies e escolha Add.
5. 6.
Selecione o nome do conjunto a partir da lista que aparece. Esses são os conjuntos que estão em cache de conjunto global. Clique em Select.
COMO: Importar um Conjunto de Permissão Usando um Arquivo XML O arquivo XML pode conter um conjunto de permissão (com ou sem uma permissão personalizada) que contém as permissões do aplicativo precisa ser executado. Você pode importar a permissão definir em Diretiva de segurança usando o Ferramenta Configuração estrutura .NET (Mscorcfg.msc) ou usando o Ferramenta Code Access Security Policy (Caspol.exe). Adicionando uma permissão personalizada usando a ferramenta Configuração .NET Framework O exemplo a seguir mostra um conjunto de permissões e uma permissão dentro de um arquivo XML.
O elemento pode conter qualquer número de elementos, que representam as permissões no conjunto de permissões. O class atributo normalmente contém o valor "NamedPermissionSet" ou "System.Security.NamedPermissionSet". O version atributo indica a versão do .NET Framework. O Name atributo é o nome da permissão definido como ele aparece na ferramenta .NET Framework Configuration. O Description atributo fornece uma
Visual C# Consolidado
633
descrição do conjunto de permissões. Do Name você pode modificar ambos e Description atributos. Cuidado Antes de adicionar permissão definida como diretiva de segurança, você talvez precise alterar o arquivo XML para que o estado das permissões atenda às suas necessidades. Consulte a documentação do aplicativo para saber sobre os atributos específicos para a permissão e como alterar seu estado.
Para importar uma permissão definir de um arquivo XML utilizando Mscorcfg.msc 1.
No.NET Framework 1.0 e 1.1, digite o seguinte no %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc Prompt de comando. Do Prompt de comando SDK no .NET Framework 2.0, inicie e tipo mscorcfg.msc. A interface de usuário para a ferramenta é exibida.
2.
Expanda o Runtime Security Policy nó.
3.
Expanda o nó para o nível de diretiva você deseja adicionar uma permissão definida.
4.
Clique com o botão direito do mouse Permission Sets e selecione New.
5.
Clique em Import e selecione o arquivo XML que contém as informações sobre o conjunto de permissões.
6.
Associar permissão definido com um grupo de códigos. Para obter detalhes, consulte Configurar grupos de códigos usando a ferramenta Configuração .NET Framework (Mscorcfg.msc).
Adicionando uma permissão personalizada usando Access Código a ferramenta Diretiva de segurança Os Ferramenta Code Access Security Policy (Caspol.exe) ships com o .NET Framework SDK e oferece suporte script para alterar a diretiva de segurança. Você pode usar Caspol.exe para adicionar novos conjuntos de permissões, mas não para modificar permissão conjuntos. Se o arquivo XML tiver somente uma permissão — um conjunto — de permissões e você não desejar adicionar a permissão usando Caspol.exe, você deve colocá a permissão entre um conjunto de permissões.
Para adicionar uma permissão definida por meio Caspol.exe •
Digite o seguinte comando no prompt de comando: caspol {-enterprise|-machine|-user} -addpset xmlFile Neste comando, xmlFile é o nome do arquivo que contém o conjunto de permissões e a permissão.
COMO: Localizar Assemblies Usando DEVPATH Os desenvolvedores podem desejar certificar-se que um conjunto compartilhado que está criando funciona corretamente com vários aplicativos. Em vez de continuamente colocar o conjunto no cache de conjunto global durante o ciclo de desenvolvimento, o desenvolvedor pode criar uma variável de ambiente DEVPATH que aponta para o diretório de saída da compilação para o conjunto.
Visual C# Consolidado
634
Por exemplo, suponha que que você estiver criando um conjunto compartilhado chamado MySharedAssembly e a pasta de saída é C:\MySharedAssembly\Debug. Você pode colocar C:\MySharedAssembly\Debug na variável DEVPATH. Em seguida, especifique o < developmentMode > elemento no arquivo de configuração do computador. Este elemento informa o Common Language Runtime para usar DEVPATH para localizar conjuntos. O conjunto compartilhado deve ser localizável pelo tempo de execução. Para especificar uma pasta particular para resolver conjunto referências usam o Element ou Element Em uma configuração arquivo, conforme descrito em Especificar local um conjunto na. Você também pode colocar o conjunto em um subdiretório do diretório do aplicativo. Para obter mais informações, consulte Como o tempo de execução localiza conjuntos de módulos (assemblies). Observação Isso é um recurso avançado, direcionado somente para desenvolvimento. O exemplo a seguir mostra como para fazer com que o tempo de execução para procurar por conjuntos em diretórios especificados pela variável do ambiente DEVPATH. Exemplo
Essa configuração será definido padrão como False. Observação Use esta configuração somente no tempo de desenvolvimento. Tempo de execução não verifica as versões em conjuntos de nome seguro encontrados no DEVPATH. Ele simplesmente usa o primeiro conjunto que encontrar.
COMO: Registrar um Objeto Ativado pelo Servidor e um Objeto Ativado pelo Cliente para um Domínio de Aplicativo de Host O exemplo a seguir mostra como registrar um objeto servidor-activated e um objeto activated cliente-para um domínio do aplicativo host. O type atributo na marca indica o nome completo do tipo e nome do conjunto do objeto, como ele aparece na marca . Exemplo
COMO: Exibir a Política de Segurança Usando Caspol.exe Do Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) você pode usar para exibir a diretiva de segurança (hieraquia de grupo de código) e uma lista de conjuntos de permissões conhecidos para todos os níveis de diretiva ou para um nível único diretiva.
Visual C# Consolidado
635
Para exibir a diretiva de segurança •
Digite o seguinte comando no prompt de comando: [caspol -enterprise | -all | -machine | -user] –list Especificar a opção Nível diretiva antes da –list opção.Se você omitir a opção Nível de diretiva, Caspol.exe mostra a hierarquia de grupo de código e conhecido permissão nomeada Define a diretiva padrão no nível Para administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de diretiva de usuário.
Ter Grupos de códigos um número de referência e, opcionalmente, um nome. Você pode usar um para se referir a grupos de códigos específicos. Lista Caspol.exe o nome condição de participação e um valor condição de participação (se houver), seguido do nome de conjunto de permissões associado a esse grupo de códigos. Se o grupo de códigos mescla as permissões de seus grupos de código filho usando lógica match first-, Caspol.exe indica isso através da exibição (FirstMatchCodeGroup.) ao lado do grupo de código A lógica de mesclagem padrão executa uma união das permissões que grupos de códigos filho conceder. Para obter mais informações, consulte Modelo de diretiva de segurança. Após a hierarquia de grupo de código é uma lista dos conjuntos nomeados de permissão conhecido em que nível de diretiva e uma lista de conjuntos confiança total, também conhecidos como conjuntos de diretiva.
COMO: Adicionar Conjuntos de Permissão usando Caspol.exe Você pode usar para adicionar permissão define como um grupo de códigos. o Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) Antes você pode associar uma permissão nomeada definido com um grupo de códigos, ele deve ser conhecido no nível de diretiva do grupo de código. Antes que você possa adicionar permissão definida com nível de diretiva do grupo de código, você deve criá-lo como um arquivo XML. Para adicionar uma permissão nomeada defina como um nível de diretiva •
Digite o seguinte comando no prompt de comando: [caspol -enterprise [permissionSetName | -machine | -user] -addpset xmlFile ] Especificar a opção Nível diretiva antes da –addpset opção.Se você omitir a opção Nível de diretiva, Caspol.exe adiciona o conjunto de permissões no nível de diretiva padrão. Para administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de diretiva de usuário. Forneça um nome conjunto de permissão se o arquivo XML não contiver um na forma de um valor de atributo nome. O comando a seguir importa o MyPermissions.xml arquivo conjunto de permissão como a MyPermissions permissão definida no nível de diretiva da máquina. caspol -machine –addpset MyPermissions.xml MyPermissions
COMO: Alterar Grupos de Código Usando Caspol.exe Use a –chggroup opção de para alterar o nome, condição de membro, conjunto de permissões, sinalizadores, ou a descrição de um grupo de códigos. o Ferramenta Diretiva de segurança para acesso de código (Caspol.exe)Você pode alterar um, alguns, ou todos os esses atributos de grupo de código Para alterar um grupo de códigos
Visual C# Consolidado
636
•
Digite o seguinte comando no prompt de comando: caspol [-enterprise|-machine|-user] –chggroup label|name {[mship] [pset_name] [-exclusive {on|off}][-levelfinal {on|off}] [-name name] [-description description_text] } Especificar a opção Nível diretiva antes da –chggroup opção.Se você omitir a opção Nível de diretiva, Caspol.exe altera o grupo de códigos especificada no nível de diretiva padrão. Para administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de diretiva de usuário. A sintaxe e significado de mship, pset_name, -exclusive, e -levelfinal são o mesmo usado para a –addgroup opção.Para obter mais informações sobre esses argumentos e opções, consulte Como adicionar grupos de códigos usando Caspol.exe:. O comando a seguir altera a condição de membro para o grupo de códigos rotulado 1.2.1. para a Internet condição de membro da zona. caspol –chggroup 1.2.1. –zone Internet
O comando a seguir altera o nome do rotulado 1.2.1.1. para MyApp_CodeGroup o grupo de códigos. caspol –chgroup 1.2.1.1. –name MyApp_CodeGroup
O comando a seguir associa permissão Internet definido com o grupo 1.3. de códigos e desliga o -exclusive Sinalizador. caspol –chggroup 1.3. Internet –exclusive off
Cuidado Alterar um grupo de códigos pode ter largura repercussões para segurança. Use esta opção com cuidado.
COMO: Configurar Canais O exemplo a seguir, mostra como para criar com um nome que é diferente de " http " e utilizá-la de um aplicativo do servidor. um HttpChannel Exemplo
Consulte também
COMO: Ativar e Desativar a Segurança Usando Caspol.exe Você pode usar para Ativar segurança e a. o Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) Quando a segurança de acesso ao código é desativada, todas as demandas de acesso ao código êxito. Desativar a segurança de acesso ao código torna o sistema vulnerável a ataques por código mal-intencionado, como vírus e worms. A desativação de segurança obtém alguns desempenho extra mas só deve ser feito quando outras medidas de segurança ter sido seguidas para ajudar a proteger exemplos de segurança do sistema. Exemplos de outras precauções de segurança incluem desconectando de redes públicas, fisicamente proteger computadores, e assim por diante.
Visual C# Consolidado
637
Cuidado Desativando a segurança de acesso ao código é uma operação todo computador-que termina verificações de segurança para todo código gerenciado e para todos os usuários no computador. Embora a –list opção mostra que Segurança está desativada, nada mais claramente indica para outros usuários que segurança tenha sido desativada.Se versões lado a lado-do Common Language Runtime são instaladas, esse comando desativa a segurança para cada versão do tempo de execução instalado no computador. Para desativar a segurança Digite o seguinte comando no prompt de comando:
•
caspol –security off
Para ativar segurança Digite o seguinte comando no prompt de comando:
•
caspol –security on
COMO: Remover Permissões de um Conjunto de Permissões Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para remover uma permissão de um conjunto de permissão. Observação O.NET Framework inclui diversos conjuntos de permissão interna. O conjunto de permissões somente internos que pode ser alterado é o Everything conjunto de permissão. Para remover uma permissão de uma permissão definido usando Mscorcfg.msc 1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando: o o
Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc.
2.
Expanda o Runtime Security Policy nó.
3.
Expanda o nó para o nível de diretiva que deseja remover a permissão de.
4.
Expanda o Permission Sets nó.
5.
Clique com o botão direito do mouse no conjunto de permissão você deseja remover a permissão de e escolha Change Permissions.
6.
Selecione uma permissão a partir da Assigned Permissions lista e clique em Remove.
7.
Clique em Finish.
Como: Executar tarefas de política de segurança comuns usando a ferramenta de configuração do .NET Framework (Mscorcfg.msc) Visual C# Consolidado
638
Do Ferramenta Configuração estrutura .NET (Mscorcfg.msc) você pode usar para configurar a diretiva de segurança para atender às suas necessidades. A tabela a seguir descreve algumas das tarefas você pode executar. Tarefas de diretiva de segurança
Descrição
Novo
Criar um novo arquivo de diretiva. Use esta opção para criar e implantar novos arquivos de nível de diretiva sem afetar a diretiva no computador atual.
Abrir
Abra um nível de diretiva. Use esta opção para abrir arquivos criados usando a New opção de diretiva.
Redefinir tudo
Redefinir todos os níveis de diretiva para o padrão.
Ajustar Segurança
Ajuste o nível de segurança para cada zona.
Avaliar Conjunto de Módulos (Assembly)
Exibir as permissões concedidas a um conjunto ou os grupos de códigos que conceder permissões a um conjunto.
Confiar assembly
Atribuir um nível de confiança a um conjunto.
Criar um pacote de implantação
Criar e implantar a diretiva de segurança em uma rede.
Para executar essas tarefas com base em segurança 1.
Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc). 1.
No Painel de Controle, abra Ferramentas administrativas.
2.
Clique duas vezes Microsoft .NET Framework Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando: Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc.
o
Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc.
o
2.
No painel esquerdo, clique com o botão direito do mouse no Runtime Security Policy nó.
3.
Escolha a tarefa que deseja executar a partir do menu.
Como Criar um Gerenciador de Recursos de Compensação (CRM) Exemplo do código Um gerenciador de recursos de compensação (CRM) é um serviço fornecido pelo COM + que permite que você para incluir objetos não transacional em transações Microsoft Distributed transações distribuídas (DTC). Embora os CRMs não fornecem os recursos do Gerenciador de recursos completo, eles fazer fornecem atomicidade transacional (comportamento All-or-Nothing) e durabilidade através o log de recuperação. Para criar um gerenciador de recursos Compensating 1. Importar os espaços para nome EnterpriseServices e CompensatingResourceManager. C# using System.EnterpriseServices; using System.EnterpriseServices.CompensatingResourceManager;
Visual C# Consolidado
639
2. Ativar o suporte do CRM para o conjunto. C# [assembly: ApplicationCrmEnabled]
3. Definir uma classe do operador CRM que deriva da classe ServicedComponent. Por exemplo, o código a seguir mostra uma classe CRMWorker que deriva diretamente de ServicedComponent. C# [Transaction] public class CRMWorker:ServicedComponent { }
4. Implementar um método público que cria um objeto Clerk e confirma ou anula a transação. O método deve atualizar o log do CRM usando o objeto Clerk. Por exemplo, o código a seguir mostra um método CRMMethod que atualiza o log do CRM e confirma ou anula a transação. C# public void CRMMethod(string fileName, bool bCommit) { // Create clerk object. Clerk clerk = new Clerk(typeof(CRMCompensator), "CRMCompensator", CompensatorOptions.AllPhases); clerk.WriteLogRecord(fileName); clerk.ForceLog(); if (bCommit) ContextUtil.SetComplete(); else ContextUtil.SetAbort(); }
5. Definir uma classe que deriva da classe compensação. C# [JustInTimeActivation] public class CRMCompensator:Compensator { }
Observação Você deve aplicar o JustInTimeActivation atributo para o compensador; caso contrário anular é chamado duas vezes. 1. Substituir e EndAbort membros da classe Compensator., EndPrepare, CommitRecordBeginCommit, BeginAbortEndCommit, AbortRecord a BeginPrepare, PrepareRecord
2. Criar um aplicativo do cliente para testar os componentes do operador CRM e Compensator. 1. Importar os nomes necessários, como o System.EnterpriseServices e espaço para nome que implementa as classes do operador CRM e Compensator. C# using System; using System.IO; using System.EnterpriseServices; using CrmServer; using System.Runtime.InteropServices;
2. Definir uma classe e implementar o método principal para criar uma instância da classe do operador CRM, e chamar esse método que cria o objeto Clerk CRM. Por exemplo, o código a seguir cria um objeto do tipo CRMWorker e chama o método CRMMethod para criar o objeto Clerk CRM. C# class CRM { public static int Main() { string logfilename = "crm.log"; Console.WriteLine("Creating a managed CRM worker object..."); CRMWorker crmworker = new CRMWorker(); Console.WriteLine("Demonstrating a worker commit..."); crmworker.CRMMethod(logfilename, true); Console.WriteLine("Demonstrating a worker
3. Gerar uma chave forte e compilar o exemplo a seguir. C# sn –k crm.key csc /t:library /r:System.EnterpriseServices.dll crm.cs csc /r:crm.dll crmclient.cs
Exemplo C# using System; using System.IO; using System.Reflection; using System.EnterpriseServices; using System.EnterpriseServices.CompensatingResourceManager; [assembly: ApplicationActivation(ActivationOption.Server)] [assembly: ApplicationCrmEnabled] [assembly: AssemblyKeyFile("crm.key")] namespace CrmServer { [Transaction] // Create a Worker class. public class CRMWorker:ServicedComponent { public void CRMMethod(string fileName, bool bCommit) { // Create clerk object. Clerk clerk = new Clerk(typeof(CRMCompensator), "CRMCompensator", CompensatorOptions.AllPhases); clerk.WriteLogRecord(fileName); clerk.ForceLog(); if (bCommit) ContextUtil.SetComplete(); else ContextUtil.SetAbort(); } } // Create class derived from Compensator class. [JustInTimeActivation] public class CRMCompensator:Compensator { bool bBeginPrepareCalled = false; bool bPrepareRecordCalled = false; bool bBeginCommitCalled = false; bool bCommitRecordCalled = false; bool bBeginAbortCalled = false; bool bAbortRecordCalled = false; String _fileName; public override void BeginPrepare() { bBeginPrepareCalled = true; } public override bool PrepareRecord(LogRecord rec) { Object o = rec.Record; _fileName = o.ToString(); bPrepareRecordCalled = true; return false; } public override bool EndPrepare() { if (!bBeginPrepareCalled) {return false;} if (!bPrepareRecordCalled) {return false;} if (_fileName==null) {return false;} // This is a Prepare Phase success. return true; } public override void BeginCommit(bool fRecovery) { bBeginCommitCalled = true; } public override bool CommitRecord(LogRecord rec) { bCommitRecordCalled = true; return true; } public override void EndCommit() { if (!bBeginCommitCalled) {return;} if (!bCommitRecordCalled) {return;} if (_fileName==null) {return;} // This is a Commit Phase success. } public override void BeginAbort(bool fRecovery) { bBeginAbortCalled = true; } public override bool AbortRecord(LogRecord rec) { bAbortRecordCalled = true; Object o = rec.Record; _fileName = o.ToString(); return true; } public override void EndAbort() { if (!bBeginAbortCalled) {return;} if (!bAbortRecordCalled) {return;} if (_fileName==null) {return;} // This is an Abort Phase success. } } }
Como Criar um Serviced Component O procedimento a seguir descreve como criar um novo componente de serviço. Para criar um componente de serviço 1. Definir uma classe que deriva direta ou indiretamente a partir da ServicedComponent classe. Por exemplo, o código a seguir garante que a Calculator classe é hospedada por um aplicativo do COM +. C# using System.EnterpriseServices; public class Calculator : ServicedComponent { public int Add (int x, int y) { return(x+y); } }
2. Aplicar atributos para indicar como cada conjunto, classe, ou método deve interagir com funcionalidade com +.
Visual C# Consolidado
641
Observação No.NET Framework versão 1.1, a configuração de segurança do COM + é habilitada por padrão se o ApplicationAccessControlAttribute atributo não está presente no conjunto. Isso é uma alteração no comportamento de .NET Framework versão 1.0. C# [assembly: ApplicationName("Calculator")] [assembly: System.Reflection.AssemblyKeyFile("Calculator.snk")] [MustRunInClientContext] public class Calculator : ServicedComponent { // Member definitions. }
3. Gerar uma chave forte e compilar o exemplo a seguir: C# sn –k Calculator.snk csc /t:library /r:System.EnterpriseServices.dll Calculator.cs
4. Implantar o aplicativo de componentes atendidos por registrar seu conjunto dinamicamente ou manualmente. 5. Após um componente de serviço estiver registrado, os clientes podem criar instâncias do componente como eles criar instâncias de qualquer outro componente. Para obter um exemplo completo, consulte Exemplo de serviço do componente. Observação Em plataformas Windows 2000, com + sempre carrega a versão mais recente do Common Language Runtime do para o componente você está criando. Isso significa que em um computador com o .NET Framework versão 1.0 e .NET Framework versão 1.1 instalado,.NET Framework versão 1.1 é carregado sempre. Como uma solução, você pode criar um arquivo Dllhost.exe.Configuration COM + que permite que você para “ bloquear ” todos os aplicativos para uma versão específica do .NET Framework. No Windows xp e plataformas Windows Server 2003, a configuração diretório raiz de aplicativo pode ser usada para apontar com + para uma pasta apropriada para seu arquivo de configuração. Exemplo C# using System.EnterpriseServices; [assembly: ApplicationName("Calculator")] [assembly: System.Reflection.AssemblyKeyFile("Calculator.snk")] [MustRunInClientContext] public class Calculator : ServicedComponent { public int Add (int x, int y) { return(x+y); } }
Como Aplicar o Atributo Description a um Assembly O exemplo a seguir mostra como aplicar o DescriptionAttribute atributo para definir a descrição de um conjunto. Exemplo C# using System.EnterpriseServices; [ assembly: Description("BankComponent assembly")] public class Account : ServicedComponent { static void Main() {} }
Visual C# Consolidado
642
Compilando o código Este exemplo requer: Referências a espaços para nome do sistema e System.EnterpriseServices.
•
Como Usar os Métodos SetAbort e SetComplete Este exemplo mostra como usar o estático SetComplete e SetAbort métodos da classe System.EnterpriseServices.ContextUtil. Para obter mais informações sobre esses métodos, consulte Votação em uma transação automáticas. Exemplo C# //Try to do something crucial to the transaction in progress. if( !DoSomeWork() ) { ContextUtil.SetAbort(); //Something goes wrong. } else { ContextUtil.SetComplete(); //All goes well. }
Compilando o código Este exemplo requer: Referências a espaços para nome do sistema e System.EnterpriseServices.
•
Como Aplicar o Atributo ApplicationID a um Assembly Este exemplo mostra como aplicar o atributo ApplicationID a um conjunto. Exemplo C# using System.EnterpriseServices; [ assembly: ApplicationName("BankComponent")] [ assembly: ApplicationID("4fb2d46f-efc8-4643-bcd0-6e5bfa6a174c")] public class Account : ServicedComponent { static void Main() {} }
Compilando o código Este exemplo requer: Referências a espaços para nome do sistema e System.EnterpriseServices
•
Como Criar um Objeto de Pool e Definir seus Limites de Tamanho e de Tempo Para uma classe que deriva da classe System.EnterpriseServices.ServicedComponent, com + Objeto pool pode usar para evitar a sobrecarga de instanciar objetos de zero. Em vez disso objetos obter recebidos de um pool quando ativado. Para obter mais informações, consulte Objeto pool. Para criar um objeto agrupado e definir seu tamanho e tempo limite limita 1.
Definir uma classe que deriva da classe System.EnterpriseServices.ServicedComponent, e aplique o ObjectPoolingAttribute atributo à classe. Por exemplo, o código a seguir define uma classe denominada TestObjectPooling e define e CreationTimeout propriedades para a classe. o MinPoolSize, MaxPoolSize C#
Visual C# Consolidado
643
[ObjectPooling(Enabled=true, MinPoolSize=2, MaxPoolSize=5, CreationTimeout=20000)] public class TestObjectPooling : ServicedComponent { }
2. 3.
Substituir o Activate, Deactivate., e CanBePooled métodos de classe System.EnterpriseServices.ServicedComponent Teste o objeto em pool, em um aplicativo do cliente: 1.
Criar uma instância da classe do objeto agrupada e chamar os métodos no objeto em pool. Por exemplo, o código a seguir cria uma instância da classe TestObjectPooling e chama um Perform método. C# public class App { public static int Main(string[] args) { TestObjectPooling order = new TestObjectPooling(); order.Perform();
2.
Chame o método DisposeObject para retornar o objeto para o pool. C# ServicedComponent.DisposeObject (order);
Exemplo C# [ObjectPooling(Enabled=true, MinPoolSize=2, MaxPoolSize=5, CreationTimeout=20000)] public class TestObjectPooling : ServicedComponent { public void Perform () { // Method contents go here. } protected override void Activate() { // Called when removed from the pool. } protected override void Deactivate() { // Called before deactivating or placing back in pool. } protected override bool CanBePooled() { // Called after Deactivate. Indicate your vote here. return true; } }
Como criar um Método de Web Service que Usa Transações Automáticas O procedimento a seguir descreve como criar um método de serviço da Web que usa transações automáticas. Se ocorrer uma exceção enquanto um método de serviço da Web está participando em uma transação, ASP.NET anula automaticamente a transação. Da mesma forma, se nenhuma exceção ocorrer, a transação é confirmada automaticamente. Para criar um serviço da Web que usa transações automáticas 1.
Importar os espaços para nome System.WebServices e System.EnterpriseServices. Outros espaços para nomes, tais como System.Data e System.Data.SqlClient, podem ser importado conforme necessário. C# <%@ WebService Language="C#" Class="Orders" %> <%@ assembly name="System.EnterpriseServices" %> using System.Web.Services; using System.EnterpriseServices;
2.
Definir uma classe que deriva da classe WebService. Por exemplo, o código a seguir define uma classe denominado Pedidos que deriva da classe WebService. C# public class Orders : WebService { }
3.
Para cada método Web que deve participar automaticamente de uma transação, aplicar o WebMethodAttribute atributo, e definir a opção da transação. Por exemplo, no código a seguir o atributo WebMethod é aplicado para o DeleteAuthor método, e a TransactionOption propriedade é definida como TransactionOption.RequiresNew.
Visual C# Consolidado
644
C# [ WebMethod(TransactionOption=TransactionOption.RequiresNew)] public int DeleteAuthor(string lastName) { // Perform the required database task. }
Exemplo C# <%@ WebService Language="C#" Class="Orders" %> <%@ assembly name="System.EnterpriseServices" %> using System; using System.Data; using System.Data.SqlClient; using System.Web.Services; using System.Web.Util; using System.EnterpriseServices; public class Orders : WebService { [ WebMethod(TransactionOption=TransactionOption.RequiresNew)] public int DeleteAuthor(string lastName) { String deleteCmd = "DELETE FROM authors2 where au_lname='" + lastName + "'" ; SqlConnection sqlConn = new SqlConnection("Integrated Security=SSPI;database=pubs;server=myserver"); SqlCommand myCommand = new SqlCommand(deleteCmd,sqlConn); // If a Web service method is participating in a transaction and an // exception occurs, ASP.NET automatically aborts the transaction. // Likewise, if no exception occurs, then the transaction is // automatically committed. myCommand.Connection.Open(); return myCommand.ExecuteNonQuery(); } }
Como Definir a Propriedade SoapRoot Property para um Aplicativo Este exemplo mostra como definir a propriedade SoapVRoot " MyVRoot ". Exemplo C# [ApplicationActivation(ActivationOption.Library, SoapVRoot="MyVRoot")]
Compilando o código Este exemplo requer: Referências para o sistema e System.EnterpriseServices Namespace espaços para nome
•
Como Definir o Tempo Limite da Transação Este exemplo mostra como definir o limite de transação como 10 segundos. Exemplo C# [Transaction(TransactionOption.Required, Isolation=TransactionIsolationLevel.Serializable, Timeout=10)]
Compilando o código Este exemplo requer: •
Referências ao espaço para nome System.EnterpriseServices.
Como Definir o Nome do Aplicativo Usando o Atributo ApplicationName Este exemplo mostra como para fornecer o nome do aplicativo, usando o conjunto - atributo ApplicationName.
Visual C# Consolidado
645
Exemplo C# using System.EnterpriseServices; [ assembly: ApplicationName("BankComponent")] public class Account : ServicedComponent { static void Main() {} }
Compilando o código Este exemplo requer: Referências para o sistema e System.EnterpriseServices espaços para nome.
•
Como Usar o Recurso BYOT (Bring Your Own Transaction - Traga sua Própria Transação) do COM+ Exemplo do código O procedimento e exemplo a seguir mostram como uma classe derivada da classe ServicedComponent pode usar o recurso BYOT do COM + para acessar um coordenador transações distribuídas (DTC). Para obter mais informações como utilizar o recurso BYOT de dentro do espaço de nome System.EnterpriseServices, consulte BYOT (colocar seu próprio Transaction). Para criar um objeto que usa a transação de outro objeto. 1.
Definir uma classe que deriva da classe ServicedComponent, e expõe uma propriedade pública que retorna o objeto transações DTC com + atual. Por exemplo, no código a seguir a classe Base, herda a classe ServicedComponent e tem uma propriedade pública que retorna o objeto ContextUtil.Transaction para a transação COM + DTC atual no qual o objeto é instanciado. C# using System.EnterpriseServices; public class Base : ServicedComponent { public Object Transaction { get { return ContextUtil.Transaction; } } }
2.
Crie duas classes que derivar da classe definida na etapa 1 e defina o atributo de transações para ambas as classes. Por exemplo, o código a seguir declara duas classes CTransaction1 e CTransaction2 derivar de classe Base, e têm seu conjunto de atributos de transações. C# [Transaction] public class CTransaction1 : Base { // Insert your transaction logic here. } [Transaction] public class CTransaction2 : Base { // Insert your transaction logic here. }
3.
Criar um aplicativo do cliente que usa as classes criadas na etapa 2 para testar o recurso BYOT. 1.
Criar uma instância de uma das classes definidas na etapa 2. Por exemplo, o código a seguir cria uma instância da classe CTransaction1. C# class BYOTDemonstration { static void Main() { CTransaction1 tx1 = new CTransaction1(); } }
2.
Recuperar a transação COM + DTC atual do objeto criado no 3.a etapa. Por exemplo, o código a seguir recupera o objeto transações a partir da propriedade Transaction pública da classe CTransaction1. C#
Visual C# Consolidado
646
Object tx = tx1.Transaction;
3.
Criar uma instância da classe segundo definiu na etapa 2, usando o objeto Transaction recuperado em 3.b etapa. Por exemplo, o código a seguir cria uma instância da classe CTransaction2 usando o Transaction recuperada em 3.b etapa. C# CTransaction2 tx2 = (CTransaction2)BYOT.CreateWithTransaction(tx, typeof(CTransaction2));
4.
Gerar uma chave forte e compilar o exemplo a seguir: C# sn –k BYOTDemo.snk
Exemplo C# using System; using System.Reflection; using System.EnterpriseServices; [assembly: AssemblyKeyFileAttribute("byotdemo.snk")] public class Base : ServicedComponent { public Object Transaction { get { return ContextUtil.Transaction; } } } [Transaction] public class CTransaction1 : Base { // Insert your transaction logic here. } [Transaction] public class CTransaction2 : Base { // Insert your transaction logic here. } class BYOTDemonstration { static void Main() { /* Create a transactional object, and then get its transaction. */ CTransaction1 tx1 = new CTransaction1(); Console.WriteLine("Created transaction1."); Object tx = tx1.Transaction; Console.WriteLine("Got the transaction of transaction1."); CTransaction2 tx2 = (CTransaction2)BYOT.CreateWithTransaction(tx, typeof(CTransaction2)); Console.WriteLine("Created transaction2 using the transaction of transaction1."); } }
Como Criar um Componente Privado Este exemplo mostra como usar o atributo PrivateComponentAttribute em uma classe. Exemplo C# [PrivateComponent] public class CPrivate : ServicedComponent
Compilando o código Este exemplo requer: •
Referências ao espaço para nome System.ServiceProcess.
Como Definir o Tipo de Ativação de um Aplicativo Este exemplo mostra como definir o tipo de ativação para " Servidor ". Exemplo C# using System.EnterpriseServices; [ assembly: ApplicationActivation(ActivationOption.Server)] public class Account : ServicedComponent { static void Main() {} }
Compilando o código
Visual C# Consolidado
647
Este exemplo requer: Referências para o sistema e System.EnterpriseServices espaços para nome.
•
Como Habilitar Sincronização em Instâncias de uma Classe O exemplo a seguir mostra como habilitar a sincronização em instâncias da classe TestSync . Exemplo C# [Synchronization] public class TestSync : ServicedComponent
Compilando o código Este exemplo requer: Referências para o sistema e System.EnterpriseServices espaços para nome.
•
Como Usar Transações Automáticas em uma Classe do .NET Framework O procedimento a seguir descreve como preparar uma classe para participar de uma transação automática. Para preparar uma classe para participar de uma transação automática 1.
Do TransactionAttribute derivar sua classe de classe ServicedComponent, e aplicar à sua classe. O exemplo a seguir mostra como aplicar o atributo TransactionAttribute a uma classe derivada da classe ServicedComponent. C# [Transaction(TransactionOption.Required)] public class Account : ServicedComponent { //. . . }
2.
Aplicar o atributo AutoCompletar para cada método para o qual o método ContextUtil.SetComplete deve ser chamado automaticamente na ausência de exceções. O exemplo a seguir mostra como aplicar o atributo AutoCompletar. C# [AutoComplete] public void Debit(int amount) { // Do some database work. Any exception thrown here aborts the // transaction; otherwise, transaction commits. }
3.
Assinar o assembly com um strong name. Do AssemblyKeyFileAttribute para assinar o conjunto usando atributos, crie um par de chaves usando Sn.exe, e adicione ou AssemblyKeyNameAttribute Conjunto atributo e especifique o nome do arquivo que contém o par de chaves para assinar o conjunto com um nome de alta segurança. C# [assembly: AssemblyKeyFileAttribute("TestApp.snk")]
4. 5.
Registrar o conjunto que contém a classe com o catálogo COM +. Se as instâncias de chamada de sua classe do cliente é gerenciado pelo Common Language Runtime, o registro será executado para você. No entanto, se você prevê que um chamador não gerenciado pode criar e chamar instâncias da sua classe, usar a ferramenta de instalação dos Serviços .NET (Regsvcs.exe) para executar o Registro manualmente.
Exemplo C#
Visual C# Consolidado
648
// ----------------------------------------------------------------- // TestApp.cs // Generate a Strong name: // sn -k TestApp.snk // Compile the code: // csc /target:exe /r:System.EnterpriseServices.dll TestApp.cs // Run TestApp: // start TestApp.exe // ----------------------------------------------------------------- using System; using System.Runtime.CompilerServices; using System.EnterpriseServices; using System.Reflection; //Registration details. //COM+ application name as it appears in the COM+ catalog. [assembly: ApplicationName("TestApp")] //Strong name for assembly. [assembly: AssemblyKeyFileAttribute("TestApp.snk")] [Transaction(TransactionOption.Required)] public class Account : ServicedComponent { //Provides SetComplete behavior in the absence of exceptions. [AutoComplete] public void Debit(int amount) { // Do some database work. Any exception thrown here aborts the // transaction; otherwise, transaction commits. } } public class client { public static int Main() { Account accountX = new Account(); accountX.Debit(100); return 0; } }
Como Habilitar Ativação JIT Este exemplo mostra como habilitar ativação JIT e desativação e de uma classe. Exemplo C# [JustInTimeActivation] public class TestJITObjectPooling : ServicedComponent
Compilando o código Este exemplo requer: Referências para o sistema e System.EnterpriseServices espaços para nome.
•
Como Definir o Atributo AutoComplete em uma Classe Transaction-Aware Este exemplo mostra a colocação de atributo AutoCompletar em uma classe reconhecem transações. Para obter mais informações sobre o AutoCompletar atributo, consulte Votação em uma transação automáticas. Exemplo C# [Transaction(TransactionOption.Supported)] public class Account : ServicedComponent { [AutoComplete] public void Debit(int amount) { // Do some database work. Any exception thrown here aborts the // transaction; otherwise, transaction commits. } }
Compilando o código Este exemplo requer: •
Referências a espaços para nome do sistema e System.EnterpriseServices.
Como Implementar um Componente Enfileirado que Exibe uma Mensagem de Forma Assíncrona Exemplo do código O serviço QC COM + fornece uma maneira de uma classe componente para ser chamado assincronamente USAR O enfileiramento de mensagens Microsoft. Para obter mais informações
Visual C# Consolidado
649
sobre componentes enfileirados derivados da System.EnterpriseServices.ServicedComponent classe, consulte O QC (queueds Components). Para implementar um componente enfileirado que exibe uma mensagem de forma assíncrona 1.
Importar espaço para nome System.EnterpriseServices. C# using System.EnterpriseServices;
2.
Defina o ApplicationActivation atributo como ActivationOption.Server; ativar o ouvinte da fila aplicativo enfileiramento e definindo o ApplicationQueuing atributo assembly, como mostrado no código de exemplo a seguir: C# [assembly: ApplicationActivation(ActivationOption.Server)] [assembly: ApplicationQueuing(Enabled=true, QueueListenerEnabled=true)]
3.
Definir uma interface na fila, e aplique o InterfaceQueuing atributo à interface. Por exemplo o código a seguir mostra o atributo InterfaceQueuing aplicada para a IQComponent interface que tenha um único método DisplayMessage. C# [InterfaceQueuing] public interface IQComponent { void DisplayMessage(string msg); }
4.
Definir uma classe que deriva da classe System.EnterpriseServices.ServicedComponent e implementa a interface na fila. Por exemplo, o código de exemplo a seguir declara uma classe denominada QComponent que deriva da classe System.EnterpriseServices.ServicedComponent e implementa a IQComponent interface. C# public class QComponent : ServicedComponent, IQComponent { public void DisplayMessage(string msg) { MessageBox.Show(msg, "Processing message"); } }
5.
Criar um aplicativo cliente e testar o componente enfileirado. 1.
Criar uma variável cujo tipo de dados é a interface na fila do qual a classe componente enfileirado é derivada. C# IQComponent iQc = null;
2.
Vincular ao moniker correspondente à interface na fila, e chamamos o método no componente enfileirado para exibir a mensagem de forma assíncrona. Por exemplo o código a seguir vincula ao componente enfileirado que corresponda à interface IQComponent, e chama o método DisplayMessage para exibir uma mensagem de forma assíncrona. C# IQComponent iQc = null; try { iQc = (IQComponent) Marshal.BindToMoniker("queue:/new:QCDemo.QComponent"); } catch { MessageBox.Show("Cannot create Queued Component"); } iQc.DisplayMessage (messageToSend.Text); Marshal.ReleaseComObject(iQc);
Exemplo C# using System.Reflection; using System.EnterpriseServices; [assembly: ApplicationName("QCDemoSvr")] [assembly: ApplicationActivation(ActivationOption.Server)] [assembly: ApplicationQueuing(Enabled=true,
Visual C# Consolidado
650
QueueListenerEnabled=true)] [assembly: AssemblyKeyFile("QCDemoSvr.snk")] namespace QCDemo { [InterfaceQueuing] public interface IQComponent { void DisplayMessage(string msg); } public class QComponent : ServicedComponent, IQComponent { public void DisplayMessage(string msg) { MessageBox.Show(msg, "Processing message"); } } }
Como Implementar Eventos Fracamente Acoplados Exemplo do código O procedimento e exemplo a seguir mostram como para implementar uma classe de evento e coletor de eventos que implementam uma interface de eventos comuns, mais um editor para acionar um evento. Para obter mais informações sobre como usar o modelo flexível coupled Eventos COM +, consulte Eventos flexível Coupled. Para implementar flexível aliada eventos 1.
Definir uma interface de eventos. Por exemplo, o código a seguir define uma interface de evento denominada IlceMsg que tenha um método chamado EventMethod. C# public interface ILceMsg { void EventMethod(string message); }
2.
Definir uma classe de evento que deriva da classe System.EnterpriseServices.ServicedComponent e implementa a interface de evento definiu na etapa 1. Por exemplo, o código a seguir define uma classe de evento chamado LceClass. C# [EventClass] public class LceClass : ServicedComponent, ILceMsg { public void EventMethod(string message){} }
3.
Definir uma classe mesmo do coletor que deriva da classe System.EnterpriseServices.ServicedComponent e implementa a interface de evento definiu na etapa 1. Por exemplo, o código a seguir define uma classe do coletor de evento chamado LceSink. C# public class LceSink : ServicedComponent, ILceMsg { public void EventMethod(string message) { MessageBox.Show(message, "Event sink"); } }
4.
Criar um editor de eventos para disparar o LCE. C# protected void Fire_Click (object sender, System.EventArgs e) { ILceMsg evt = (ILceMsg) new LceClass(); evt.EventMethod("Hello events"); }
Exemplo C# using System; using System.IO; using System.Reflection; using System.EnterpriseServices; using System.Runtime.InteropServices; [assembly: ApplicationName("EventDemo")] [assembly: ApplicationActivation(ActivationOption.Library)] [assembly: AssemblyKeyFile("EventDemoSvr.snk")] namespace EventDemo { public interface ILceMsg { void EventMethod(string message); } [EventClass] public class LceClass : ServicedComponent, ILceMsg { public void EventMethod(string message){} } public class LceSink : ServicedComponent, ILceMsg { public void EventMethod(string message) { MessageBox.Show(message, "Event sink"); } } }
Como Configurar a Construção de Objetos O procedimento e exemplo a seguir descrevem como configurar construção de objeto e definir a seqüência de inicialização padrão da classe TestObjectConstruct para a seqüência "Initial Catalog=Northwind;Data Source=.\\SQLServerInstance;Trusted_Connection=yes". Essa seqüência é usada para conectar a um banco de dados SQL Server. O tópico Construção de objeto,. explica mais o uso do COM + construção de objeto a partir da System.EnterpriseServices.ServicedComponent classe Para configurar construção de objeto e definir a seqüência de inicialização padrão para uma classe 1.
Definir uma classe que deriva direta ou indiretamente a partir da System.EnterpriseServices.ServicedComponent classe. Por exemplo, o código a seguir mostra uma classe TestObjectConstruct que deriva diretamente da classe System.EnterpriseServices.ServicedComponent. C# using System; using System.EnterpriseServices; using System.Data; using System.Data.SqlClient; … public class TestObjectConstruct : ServicedComponent { … }
2.
Aplicar o ConstructionEnabled atributo para a classe e definir propriedade do atributo Default. Por exemplo, o código a seguir se aplica o ConstructionEnabled atributo da TestObjectConstruct classe e define a Padrão propriedade como a seqüência de conexão SQL Server. C# [ConstructionEnabled(Default="Initial Catalog=Northwind;Data Source=.\\SQLServerInstance;Trusted_Connection=yes")] public class TestObjectConstruct : ServicedComponent { … }
3.
Substituir o método construir. Visual Basic _ Public Class TestObjectConstruct Inherits ServicedComponent Private m_connectStr As String Private conn as SqlConnection Protected Overrides Sub Construct(constructString As String) ' Called after constructor. m_connectStr = constructString End Sub Public Sub ConnectToDatabase() conn = New SqlConnection(m_connectStr) End Sub End Class [C#] [ConstructionEnabled(Default="Initial Catalog=Northwind;Data Source=.\\SQLServerInstance;Trusted_Connection=yes")] public class TestObjectConstruct : ServicedComponent { private string connectStr; SqlConnection conn; public TestObjectConstruct() { … } protected override void Construct(string constructString) { // Called after constructor. connectStr = constructString; } public void ConnectToDatabase() { conn = new SqlConnection(connectStr); conn.Open(); } }
4.
No aplicativo do cliente, criar uma instância da classe do componente sem especificar uma seqüência de construção, para que o padrão é usado. Por exemplo, o código a seguir cria
Visual C# Consolidado
652
uma instância da classe TestObjectConstruct, e a seqüência de construção padrão será "Initial Catalog=Northwind;Data Source=.\\SQLServerInstance;Trusted_Connection=yes". C# public class App { public static void Main() { TestObjectConstruct order = new TestObjectConstruct(); order. ConnectToDatabase(); } }
Depois de instalar o aplicativo Serviços componente, você pode especificar seqüências de construção por meio da ferramenta administrativa Serviços de componente. Para inserir uma seqüência de construção de objeto para um componente, execute as seguintes etapas: 1.
Abra a ferramenta administrativa Serviços de componente.
2.
Clique com botão direito na ferramenta administrativa Serviços de componente, mouse no componente que você deseja configurar, e, em seguida, clique em Properties.
3.
Se você não tenha definido o atributo ConstructionEnabled para True, na caixa Properties de diálogo, na guia Activation, marque a Enable object construction caixa de seleção para ativar o uso da seqüência de caracteres de construção do objeto.
4.
Se você desejar alterar a seqüência de construção do padrão especificado com o atributo ConstructionEnabled, na caixa Constructor string, insira a seqüência de construção.
Exemplo C# using System; using System.EnterpriseServices; using System.Data; using System.Data.SqlClient; [assembly : ApplicationName("OCDemo")] namespace OCDemo { [ConstructionEnabled(Default="Initial Catalog=Northwind; Data Source=.\\SQLServerInstance;Trusted_Connection=yes")] public class TestObjectConstruct : ServicedComponent { private string connectStr; SqlConnection conn; public TestObjectConstruct() { … } protected override void Construct(string constructString) { // Called after constructor. connectStr = constructString; } public void ConnectToDatabase() { conn = new SqlConnection(connectStr); conn.Open(); } } }
Como Obter Informações de Tipo e Membros de um Assembly O System.Reflection espaço para nome contém vários métodos para obter informações de um conjunto de módulos (assembly). Esta seção demonstra um dos métodos. Para obter informações adicionais, consulte Visão geral de reflexão. O exemplo a seguir obtém informações Tipo e membro de um conjunto. Exemplo C# using System; using System.Reflection; class Asminfo1 { public static void Main(string[] args) { Console.WriteLine ("\nReflection.MemberInfo"); //Get the Type and MemberInfo. //Insert the fully qualified class name inside the quotation marks in the following statement. Type MyType =Type.GetType("System.IO.BinaryReader"); MemberInfo[] Mymemberinfoarray = MyType.GetMembers(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Insta nce|BindingFlags.DeclaredOnly); //Get and display the DeclaringType method. Console.Write("\nThere are {0} documentable members in ", Mymemberinfoarray.Length); Console.Write("{0}.", MyType.FullName); foreach (MemberInfo Mymemberinfo in Mymemberinfoarray) { Console.Write("\n" + Mymemberinfo.Name); } } }
Visual C# Consolidado
653
Como Criar um Assembly de Arquivo Único Um conjunto de Arquivo Único, que é o tipo mais simples do conjunto, contém informações de tipo e implementação,, bem como o Manifesto do conjunto. Você pode usar Compiladores de linha de comando ou Visual Studio 2005 Para criar um conjunto de Arquivo Único. Por padrão, o compilador cria um arquivo de montagem com uma extensão.exe. Observação Para Visual Studio 2005 C# e Visual Basic pode ser usada somente para criar conjuntos de Arquivo Único. Se você deseja criar vários arquivos conjuntos, use Compiladores de linha de comando ou Visual Studio 2005 com as extensões Managed do C++.. ou Visual Studio 2005 Com o Managed Extensions para C++ Os procedimentos a seguir mostram como criar conjuntos de Arquivo Único usando Compiladores de linha de comando. Para criar um conjunto com uma extensão.exe •
No prompt de comando, digite o seguinte comando: < compiler command> Neste comando, compiler command é o comando do compilador para o idioma usado em seu módulo de código, e module name é o nome do módulo de código para compilar para o conjunto.
O exemplo a seguir cria um conjunto chamado myCode.exe de um módulo de código chamado myCode. C# csc myCode.cs
Visual Basic vbc myCode.vb
Para criar um conjunto com uma extensão.exe e especificar o nome do arquivo de saída •
No prompt de comando, digite o seguinte comando: < compiler command> /out: Neste comando, compiler command é o comando do compilador para o idioma usado em seu módulo de código, file name é o nome de arquivo de saída, e module name é o nome do módulo de código para compilar para o conjunto.
O exemplo a seguir cria um conjunto chamado myAssembly.exe de um módulo de código chamado myCode. C# csc /out:myAssembly.exe myCode.cs
Visual C# Consolidado
654
Visual Basic vbc /out:myAssembly.exe myCode.vb
Criando conjuntos da biblioteca Um conjunto de biblioteca é semelhante a uma biblioteca de classes. Ele contém tipos que serão referenciados por outros conjuntos, mas ele tem nenhum ponto de entrada para iniciar a execução.
Para criar um conjunto de biblioteca •
No prompt de comando, digite o seguinte comando: < compiler command> /t:library Neste comando, compiler command é o comando do compilador para o idioma usado em seu módulo de código, e module name é o nome do módulo de código para compilar para o conjunto. Você pode usar outras opções do compilador, como a /out: opção.
O exemplo a seguir cria um conjunto de biblioteca chamado myCodeAssembly.dll de um módulo de código chamado myCode. C# csc /out:myCodeLibrary.dll /t:library myCode.cs
Como: Criar um domínio de aplicativo Um host Runtime de idioma comum cria domínios aplicativos automaticamente quando eles são necessários. No entanto, você pode criar seus próprios domínios aplicativos e carregá-los esses conjuntos que você deseja gerenciar pessoal. Você também pode criar domínios de aplicativo do qual você executar código. Criar um novo domínio do aplicativo usando um dos métodos sobrecarregados CreateDomain na classe System.AppDomain. Você pode dar o domínio do aplicativo um nome e fazer referência a ela com esse nome. O exemplo a seguir cria um novo domínio do aplicativo, atribui o nome MyDomain, e seguida, imprime o nome de domínio host e domínio de aplicativo filho recém-criado para o console. Exemplo C# using System; using System.Reflection; class AppDomain1 { public static void Main() { Console.WriteLine("Creating new AppDomain."); AppDomain domain = AppDomain.CreateDomain("MyDomain"); Console.WriteLine("Host domain: " + AppDomain.CurrentDomain.FriendlyName); Console.WriteLine("child domain: " + domain.FriendlyName); }}
Visual C# Consolidado
655
Como determinar um conjunto o nome totalmente qualificado: Há várias maneiras para descobrir o nome totalmente qualificado de um conjunto no cache de conjunto global: •
Use o Ferramenta Configuração estrutura .NET (Mscorcfg.msc).
•
Exibir o diretório do cache de conjunto de módulos global.
•
Use o Global ferramenta cache assembly (Gacutil.exe).
Procedimentos
Para exibir os nomes de conjuntos totalmente qualificados no cache de conjunto global usando a ferramenta .NET Framework Configuration 1.
Clique no Start botão, aponte para Administrative Tools, e clique em Microsoft .NET Framework Configuration
2.
Clique em Manage the Assembly Cache e, clique em View List of Assemblies in the Assembly Cache.
Para obter informações sobre como usar a ferramenta Global Assembly Cache para exibir os nomes de conjuntos, totalmente qualificados Consulte Como Visualizar o Conteúdo da Cache Global de Assemblies. Do Disassembler MSIL (Ildasm.exe) para conjuntos de módulos (assemblies) que não estão no cache de conjunto global, você pode usar código para exibir as informações para o console ou a uma variável, ou você pode usar para examinar metadados do conjunto, que contém o nome totalmente qualificado. Para obter mais informações sobre como definir atributos do conjunto, como versão, cultura e nome do conjunto, consulte Definir atributos Assembly. Para obter mais informações sobre dar um conjunto um nome de alta segurança, consulte Criando e usando assemblies de nome forte. Exemplo O exemplo de código a seguir mostra como exibir o nome totalmente qualificado de um conjunto que contém uma classe especificada para o console. C# using System; using System.Reflection; class asmname { public static void Main() { Type t = typeof(System.Data.DataSet); string s = t.Assembly.FullName.ToString(); Console.WriteLine("The fully qualified assembly name containing the specified class is {0}.", s); } } Imports System Imports System.Reflection Imports Microsoft.VisualBasic ' For a class not contained in mscorlib.dll, compile this code with ' the /r: option; for example,compile the code below using: ' vbc asmname.vb /r:System.Data.dll /r:System.dll /r:System.Xml.dll ' If the class is contained in mscorlib.dll, the /r: compiler option is unnecessary. Class asmname Public Shared Sub Main() Dim t As Type = GetType(System.Data.DataSet) Console.WriteLine("The fully qualified assembly name containing the specified class is {0}.", t.Assembly.FullName.ToString()) End Sub 'Main End Class 'asmname
Como Configurar um Domínio de Aplicativo
Visual C# Consolidado
656
Você pode fornecer o Common Language Runtime com informações de configuração para um novo domínio do aplicativo usando a AppDomainSetup classe. Ao criar seus próprios domínios de aplicativo, a propriedade mais importante é ApplicationBase. As outras AppDomainSetup propriedades são usadas principalmente por hosts de tempo de execução para configurar um domínio aplicativo específico. A ApplicationBase propriedade Define o Diretório de raiz do aplicativo. Quando o Runtime precisa atender uma requisição tipo, ele investiga para o conjunto que contém o tipo no diretório especificado pela propriedade ApplicationBase. Observação Um novo domínio do aplicativo herdará apenas a ApplicationBase propriedade do criador. O exemplo a seguir cria uma instância da classe AppDomainSetup, usa esta classe para criar um novo domínio do aplicativo, grava as informações ao console, e depois descarrega o domínio do aplicativo. Exemplo C# using System; using System.Reflection; class AppDomain4 { public static void Main() { // Create application domain setup information. AppDomainSetup domaininfo = new AppDomainSetup(); domaininfo.ApplicationBase = "f:\\work\\development\\latest"; // Create the application domain. AppDomain domain = AppDomain.CreateDomain("MyDomain", null, domaininfo); // Write application domain information to the console. Console.WriteLine("Host domain: " + AppDomain.CurrentDomain.FriendlyName); Console.WriteLine("child domain: " + domain.FriendlyName); Console.WriteLine("Application base is: " + domain.SetupInformation.ApplicationBase); // Unload the application domain. AppDomain.Unload(domain); } }
Como Visualizar o Conteúdo de um Assembly Você pode usar para exibir informações linguagem intermediária (MSIL) Microsoft em um arquivo. o Disassembler MSIL (Ildasm.exe) Se o arquivo sendo examinado for um conjunto, essas informações podem incluir atributos do conjunto,, bem como referências a outros módulos e conjuntos. Essas informações podem ser útil para determinar se um arquivo é um conjunto ou parte de um conjunto, e se o arquivo possui referências a outros módulos ou conjuntos. Para exibir o conteúdo de um conjunto usando Ildasm.exe •
Type ildasm at the command prompt. Por exemplo, o comando a seguir desmonta o Hello.exe conjunto. ildasm Hello.exe
Para exibir informações manifesto do conjunto •
Clique duas vezes no ícone MANIFEST na janela Disassembler MSIL.
Exemplo O exemplo a seguir inicia com " Um Hello, básico " World programa. Depois compilar o programa, use Ildasm.exe para desmontar o conjunto Hello.exe e exibir o manifesto do conjunto.
Visual C# Consolidado
657
Visual Basic Imports System Public Module modmain Sub Main() Console.WriteLine ("Hello World using Visual Basic!") End Sub End Module using System; class MainApp { public static void Main() { Console.WriteLine("Hello World using C#!"); } } #using using namespace System; void main() { Console::WriteLine(L"Hello World using Managed Extensions!"); }
Executando o ildasm.exe Comando no conjunto Hello.exe e duas vezes no ícone MANIFEST na janela DASM IL produz o seguinte resultado: .assembly extern mscorlib { .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 1:0:2411:0 } .assembly Hello { // --- The following custom attribute is added automatically; do not uncomment. ------- // .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(bool, // bool) = ( 01 00 00 01 00 00 ) .hash algorithm 0x00008004 .ver 0:0:0:0 } .module Hello.exe // MVID: {58AD9DFD-63A6462A-8AD5-42CBC95AA147} .subsystem 0x00000003 .file alignment 512 .corflags 0x00000001 // Image base: 0x03330000
A tabela a seguir descreve cada diretiva no conjunto do manifesto da montagem Hello.exe usado no exemplo. Diretiva
Descrição
.assembly extern
Especifica outro conjunto que contém itens referenciados pelo módulo atual (, neste exemplo, mscorlib).
.publickeytoken Especifica o símbolo da chave real da montagem referenciada. .ver
Especifica o número de versão da montagem referenciada.
.assembly
Especifica o nome do conjunto.
.hash algorithm
Especifica o algoritmo hash usado.
.ver
Especifica o número de versão do conjunto.
.module
Especifica o nome dos módulos que compõem o conjunto. Neste exemplo, o conjunto consiste em apenas um arquivo.
.subsystem
Especifica o ambiente do aplicativo necessário para o programa. Neste exemplo, o valor 3 indica que este executável é executado de um console.
corflags
Atualmente um campo reservado nos metadados.
Um manifesto do conjunto pode conter um número de diretivas diferentes, dependendo do conteúdo do conjunto. Para obter uma lista abrangente das diretivas no manifesto do conjunto, consulte a documentação ECMA, especialmente " ii partição metadados: e semântica " definição e " partição III: CIL instrução Set ". A documentação está disponível online em http://msdn.microsoft.com/net/ECMA/ e http://www.ECMAInternational.org/publications/Standards/ECMA-335.htm.
Como Referenciar um Assembly de Nome Forte
Visual C# Consolidado
658
O processo na referência tipos ou recursos em um conjunto de nome seguro é normalmente transparente. Você pode fazer a referência no tempo de compilação (antecipada ligação) ou em tempo de execução. Uma referência em tempo de compilação ocorre quando você indicar o compilador para que seu conjunto faz referência outro conjunto explicitamente. Quando você usar em tempo de compilação referência, automaticamente o compilador obtém a chave pública do conjunto de nome seguro de destino e coloca-na referência do conjunto da montagem sendo compilada. Observação Um conjunto de nome seguro só pode usar tipos de outros conjuntos de nome seguro. Caso contrário a segurança do conjunto de nome seguro deve ser comprometida. Fazer uma referência a um conjunto de nome seguro em tempo de compilação •
No prompt de comando, digite o seguinte comando: < compiler command> /reference: Neste comando, compiler command é o comando do compilador para o idioma que você está usando e assembly name é o nome do conjunto de nome seguro sendo referenciado. Você pode usar outras opções do compilador, como a /t:library opção para criar um conjunto de biblioteca.
O exemplo a seguir cria um conjunto chamado myAssembly.dll que referências um conjunto de nome seguro chamado myLibAssembly.dll a partir de um módulo de código chamado myAssembly.cs. csc /t:library myAssembly.cs /reference:myLibAssembly.dll
Fazer uma referência a um conjunto de nome seguro em tempo de execução •
Quando você fazer uma referência em tempo de execução a um conjunto de nome seguro, por exemplo, usando você deve usar o nome de exibição do conjunto de nome seguro referenciado. ou Assembly.GetType métodos, o Assembly.Load A sintaxe de um nome de exibição é a seguinte:
Do PublicKeyToken, neste exemplo, é a forma hexadecimal do símbolo de chave pública. Se houver nenhum valor de cultura, use Culture=neutral. O exemplo de código a seguir mostra como usar essas informações com o Assembly.Load método. C# Assembly.Load("myDll,Version=1.0.0.1,Culture=neutral,PublicKeyToken=9b35aa32c18d4fb1");
Você pode imprimir o formato hexadecimal da chave pública e símbolo de chave pública para um conjunto específico usando o seguinte Ferramenta nome forte (SN.exe) Comando:
Visual C# Consolidado
659
sn -Tp Se você tiver um arquivo chave público, use o seguinte comando em vez disso (observe a diferença no caso com a opção de linha de comando):: (observe a diferença no caso com a opção de linha de comando) sn -tp
Como: Descarregar um domínio de aplicativo Quando você tiver terminado usando um domínio de aplicativo, descarregá-lo usando o System.AppDomain.Unload método. O Unload método normalmente desliga o domínio do aplicativo especificado. Durante o processo descarregando, nenhum novo segmento pode acessar o domínio de aplicativo, e são liberadas estruturas dados específicos de domínio – do aplicativo todos os. Conjuntos carregados no domínio de aplicativo são removidas e não estão mais disponíveis. Se um conjunto no domínio do aplicativo é domínio neutro-, dados para o conjunto permanece na memória até que o processo inteiro é desligado. Não há nenhum mecanismo para descarregar um conjunto-domínio neutro diferente desligar o processo inteiro. Há situações em que a solicitação para descarregar um domínio de aplicativo não funciona e resulta em um CannotUnloadAppDomainException.. um CannotUnloadAppDomainException O exemplo a seguir cria um novo domínio denominado MyDomain do aplicativo, imprime algumas informações ao console, e depois descarrega o domínio do aplicativo. Observe que o código tenta imprimir o nome amigável do domínio do aplicativo descarregado para o console. Essa ação gera uma exceção que é tratada pelas instruções try / catch no final do programa. Exemplo C# using System; using System.Reflection; class AppDomain2 { public static void Main() { Console.WriteLine("Creating new AppDomain."); AppDomain domain = AppDomain.CreateDomain("MyDomain", null); Console.WriteLine("Host domain: " + AppDomain.CurrentDomain.FriendlyName); Console.WriteLine("child domain: " + domain.FriendlyName); AppDomain.Unload(domain); try { Console.WriteLine(); Console.WriteLine("Host domain: " + AppDomain.CurrentDomain.FriendlyName); // The following statement creates an exception because the domain no longer exists. Console.WriteLine("child domain: " + domain.FriendlyName); } catch (AppDomainUnloadedException e) { Console.WriteLine("The appdomain MyDomain does not exist."); } } }
Como Remover um Assembly de Cache Global de Assemblies Do Ferramenta Assembly Cache global (Gacutil.exe) uso para remover um conjunto de cache de conjunto global. Para remover um conjunto de cache de conjunto global •
No prompt de comando, digite o seguinte comando: gacutil –u Neste comando, assembly name é o nome da montagem para remover do cache de conjunto global.
O exemplo a seguir remove um conjunto chamado hello.dll do cache de conjunto global.
Visual C# Consolidado
660
gacutil -u hello
O SDK do .NET Framework também fornece uma extensão Shell do Windows chamado que você pode usar para remover conjuntos de cache de conjunto global. o Visualizador cache do conjunto (Shfusion.dll),
Como Instalar um Assembly na Cache Global de Assemblies Existem quatro maneiras para instalar um conjunto no cache de conjunto global: Usando o Ferramenta Assembly Cache global (Gacutil.exe).
•
Você pode usar Gacutil.exe para adicionar conjuntos de nome seguro de cache de conjunto global e para exibir o conteúdo do cache de montagem global. Observação Gacutil.exe serve apenas para fins de desenvolvimento e não deve ser usado para instalar conjuntos de produção no cache de conjunto global. Usando o Microsoft Windows Installer 2.0.
•
Essa é a maneira recomendada e mais comum para adicionar conjuntos de cache de conjunto global. O instalador fornece referência Contagem de conjuntos no cache de conjunto global, e outros benefícios. •
Usando uma extensão do shell do Windows fornecido pelo SDK do .NET Framework chamado o Visualizador cache do conjunto (Shfusion.dll). A extensão do shell permite que você a arrastar conjuntos para cache de conjunto global. Usando o Ferramenta Configuração estrutura .NET (Mscorcfg.msc).
•
O Ferramenta Configuração estrutura .NET (Mscorcfg.msc) permite que você se exibir o cache de conjunto de módulos global e adicionar novos conjuntos de no cache. Para instalar um conjunto de nome seguro no cache de conjunto global usando a ferramenta Global Assembly Cache (Gacutil.exe) No prompt de comando, digite o seguinte comando:
•
gacutil –I Neste comando, assembly name é o nome da montagem para instalar em cache de conjunto global. O exemplo a seguir instala um conjunto com o nome hello.dll de arquivo no cache de conjunto global. gacutil -i hello.dll
Como Criar um Assembly de Múltiplos Arquivos Esta seção descreve o procedimento utilizado para criar um conjunto de vários arquivos e fornece um exemplo completo que ilustra cada uma das etapas no procedimento. Para criar um conjunto de vários arquivos 1.
Compilar todos os arquivos que contêm espaços para nome referido por outros módulos na montagem em módulos de código. A extensão padrão para módulos de código
Visual C# Consolidado
661
é.netmodule. Por exemplo, se criar um arquivo chamado Stringer espaço para nome chamada myStringer que é referenciado no arquivo Código do cliente, Stringer deve ser compilado em um módulo de código primeiro. 2.
Compilar todos os outros módulos, usando as opções do compilador necessário para indicar os outros módulos que são referenciados no código.
3.
Do Vinculador do conjunto (AL.exe) uso para criar o arquivo de saída que contém o manifesto do conjunto. Esse arquivo contém informações de referência para todos os módulos ou recursos que fazem parte do conjunto. Observação O Visual Studio 2005 IDE de C# e Visual Basic poderá somente usar para criar conjuntos de Arquivo Único. Se você desejar criar vários arquivos conjuntos, deve usar os compiladores de linha de comando ou Visual Studio 2005 com Visual C++.. ou Visual Studio 2005 com Visual C++
O exemplo a seguir ilustra a etapa 1 do procedimento acima, por compilação arquivos com espaços para nome referido por outros arquivos. Este exemplo inicia com alguns código simples para o Stringer arquivo. Espaço para nome chamado myStringer com uma classe chamado StringerStringer. A Stringer classe contém um método chamado StringerMethod que grava uma única linha para o console. C# // Assembly building example in the .NET Framework SDK. using System; namespace myStringer { public class Stringer { public void StringerMethod() { System.Console.WriteLine("This is a line from StringerMethod."); } } }
Use o seguinte comando para compilar este código: Visual Basic vbc /t:module Stringer.vb
C# csc /t:module Stringer.cs
Especificando o module parâmetro com a /t: opção de compilador indica que o arquivo deve ser compilado como um módulo em vez de como um conjunto. O compilador produz um módulo chamado Stringer.netmodule, que pode ser adicionado a um conjunto. Na Etapa dois do procedimento acima, você deve compilar módulos com referências a outros módulos. Essa etapa usa a /addmodule opção de compilador. No exemplo a seguir, um módulo de código chamado Client tem um método ponto Main de entrada que referencia um método no módulo Stringer.dll criado na etapa 1. O exemplo a seguir mostra o código para Client. C# using System; using myStringer; //The namespace created in Stringer.netmodule. class MainClientApp { // Static method Main is the entry point method. public static void Main() { Stringer myStringInstance = new Stringer(); Console.WriteLine("Client code executes"); //myStringComp.Stringer(); myStringInstance.StringerMethod(); } }
Visual C# Consolidado
662
Use o seguinte comando para compilar este código: Visual Basic vbc /addmodule:Stringer.netmodule /t:module Client.vb
Especificar a /t:module opção porque este módulo irá ser adicionado a uma montagem em uma etapa futura. Especificar a /addmodule opção porque o código em Client Referências criado pelo código em Stringer.netmodule um espaço para nome. O compilador produz um módulo chamado Client.netmodule que contém uma referência a outro módulo, Stringer.netmodule. Observação O C# e Visual Basic compiladores suportam diretamente criação usando as seguintes sintaxes diferentes dois conjuntos de vários arquivos. Dois compilations criar um conjunto-dois arquivos:
Do Vinculador do conjunto (AL.exe) você pode usar para criar um conjunto de uma coleção de compilado módulos de código.
Para criar um conjunto de vários arquivos usando o vinculador assembly •
No prompt de comando, digite o seguinte comando: al … /main: /out: /target: Os module name argumentos neste comando, especifique o nome de cada módulo para incluir no conjunto. A /main: opção especifica o nome do método que é ponto de entrada do conjunto. A /out: opção especifica o nome do arquivo de saída, que contém metadados do conjunto. A /target: opção especifica que o conjunto é um arquivo executável (.exe) do aplicativo Console, um arquivo executável (.Win) do Windows, ou um arquivo biblioteca (.lib).
No exemplo a seguir, a Al.exe cria um conjunto que é um aplicativo de console executável chamado myAssembly.exe. O aplicativo consiste de dois módulos chamados Client.netmodule e Stringer.netmodule. e o arquivo executável chamado myAssembly.exe, que contém somente
Visual C# Consolidado
663
metadados conjunto O ponto de entrada do conjunto é o Main método na classe MainClientApp, que está localizado em Client.dll. al Client.netmodule Stringer.netmodule /main:MainClientApp.Main /out:myAssembly.exe /target:exe
Do Disassembler MSIL (Ildasm.exe) você pode usar para examinar o conteúdo de um conjunto ou determinar se um arquivo é um conjunto ou um módulo.
Como Carregar Assemblies em um Domínio de Aplicativo No.NET Framework, existem várias maneiras para carregar um conjunto em um domínio de aplicativo. Cada forma usa uma classe diferente. Você pode usar os seguintes métodos sobrecarregados para carregar um conjunto em um domínio de aplicativo: •
A System.AppDomain classe contém vários métodos sobrecarregados Carga. Esses métodos principalmente são usados para interoperabilidade com, embora eles podem ser usados para carregar qualquer conjunto na atual ou um novo domínio do aplicativo com êxito. Também é possível carregar um conjunto usando os CreateInstance métodos.
•
A System.Reflection.Assembly classe contém dois métodos sobrecarregados estáticos, Carga e LoadFrom. Os dois métodos variar pelo contexto de carga.
O exemplo seguinte carrega um conjunto no domínio de aplicativo atual e executa o conjunto. Para uma discussão completa sobre como obter informações de um conjunto carregado, consulte Carregar dinamicamente e Usando tipos. Observação Na versão do .NET Framework 2.0 domínios do aplicativo possuem um contexto somente Reflection-. Conjuntos carregados neste contexto podem ser examinados mas não executado, permitindo exame de conjuntos que destino outras plataformas. Consulte Como Carregar Assemblies no Contexto Somente de Reflexão e ReflectionOnlyLoad. Exemplo C# using System; using System.Reflection; public class Asmload0 { public static void Main () { // Use the file name to load the assembly into the current application domain. Assembly a = Assembly.LoadFrom("adname.exe"); //Get the type to use. Type myType = a.GetType("adname"); //Get the method to call. MethodInfo mymethod = myType.GetMethod("adnamemethod"); //Create an instance. Object obj = Activator.CreateInstance(myType); //Execute the adnamemethod method. mymethod.Invoke(obj,null); } }
COMO: Assinar uma Assembly com Nome Forte Há duas maneiras para assinar um conjunto com um nome de alta segurança: •
Do Vinculador do conjunto (AL.exe) Usando fornecido pelo .NET Framework SDK.
Visual C# Consolidado
664
Usando atributos do conjunto para inserir as informações de nome de alta segurança em seu código. Você pode usar ou AssemblyKeyFileAttribute a AssemblyKeyNameAttribute, dependendo da onde o arquivo de chave a ser usado está localizado.
•
Você deve ter um par de chaves de criptografia para assinar um conjunto com um nome de alta segurança. Para obter mais informações sobre como criar um par de chaves, consulte Como criar um par de chaves pública / Private:. Para criar e assinar um conjunto com um nome de alta segurança usando o vinculador assembly No prompt de comando, digite o seguinte comando:
•
al /out: /keyfile: Neste comando, assembly name é o nome da montagem para entrar com um nome de alta segurança, module name é o nome do módulo do código usado para criar o conjunto, e file name é o nome do recipiente ou arquivo que contém o par de chaves. O exemplo a seguir assina o conjunto MyAssembly.dll com um nome de alta segurança usando o arquivo sgKey.snk de chave. al /out:MyAssembly.dll MyModule.netmodule /keyfile:sgKey.snk
Para assinar um conjunto com um nome de alta segurança com atributos Entre um módulo de código, adicione o AssemblyKeyFileAttribute ou o AssemblyKeyNameAttribute, especificando o nome do arquivo ou recipiente que contém o par de chaves para usar ao assinar o conjunto com um nome de alta segurança.
•
Do AssemblyKeyFileAttribute exemplo usa o seguinte código com um arquivo de chave chamado sgKey.snk, localizado na pasta onde o conjunto é compilado. Isso pressupõe que o conjunto é compilado usando o vbc.exe Compiladores de linha de comando e csc.exe. C# [assembly:AssemblyKeyFileAttribute(@"sgKey.snk")]
Observação Em ambientes de desenvolvimento, como Visual Studio, o conjunto não pode ser compilado no diretório do projeto. Por exemplo, algumas versões do Visual Studio Compilar projetos C# em um bin\Debug subdiretório. Nesse caso, o caminho no exemplo de código seria ".. \\ \\sgKey.snk ". No Visual Studio 2005 arquivo de chave no C# pode ser especificado nas configurações do projeto. Você também pode atrasar assinar um conjunto durante a compilação. Para obter mais informações, consulte Atraso assinatura um conjunto. Ao assinar um conjunto com um nome de alta segurança, a Vinculador do conjunto (AL.exe) Aparência da chave arquivos relativo para a pasta atual e para o diretório de saída. Ao usar linha comando compiladores, basta copiar a chave para a pasta atual que contém seus módulos de código.
Como Visualizar o Conteúdo da Cache Global de Assemblies Do Ferramenta Assembly Cache global (Gacutil.exe) uso para exibir o conteúdo do cache de montagem global.
Visual C# Consolidado
665
Para exibir uma lista das montagens no cache de conjunto global •
No prompt de comando, digite o seguinte comando: l Gacutil –
O SDK do .NET Framework também fornece uma extensão Shell do Windows chamado que você pode usar para exibir o conteúdo do cache de conjunto global. o Visualizador cache do conjunto (Shfusion.dll),
Como Criar um par de chaves Public/Private Para assinar um conjunto com um nome de alta segurança, você deve ter um par de chaves pública / particular Criptografia esse par de chaves pública e privada é usado durante a compilação para criar um conjunto de nome seguro. Você pode criar um par de chaves usando o Ferramenta nome forte (SN.exe). Par de Chaves arquivos geralmente têm uma extensão.snk. Para criar um par de chaves •
No prompt de comando, digite o seguinte comando: sn –k Neste comando, file name é o nome do arquivo de saída que contém o par de chaves.
O exemplo a seguir cria um par de chaves denominado sgKey.snk. sn -k sgKey.snk
Se você pretende atrasar a assinatura um conjunto e você controlar o par de chaves toda (que é improvável fora cenários de teste), você pode usar o seguinte comandos para gerar um par de chaves e então extrair a chave pública em um arquivo separado. Primeiro, crie o par de chaves: sn -k keypair.snk •
Em seguida, extrair a chave pública do par de chaves e copiá-la para um arquivo separado:
sn -p keypair.snk public.snk •
Assim que você criar o par de chaves, você deve colocar o arquivo em que ele pode localizar o nome de alta segurança assinatura ferramentas.
Ao assinar um conjunto com um nome de alta segurança, a Vinculador do conjunto (AL.exe) Aparência da chave arquivos relativo para a pasta atual e para o diretório de saída. Ao usar linha comando compiladores, basta copiar a chave para a pasta atual que contém seus módulos de código. Se você estiver usando um IDE, tais como Visual Studio 2005, para assinar um conjunto com um nome de alta segurança, é necessário compreender onde o IDE procura o arquivo de chave. Por exemplo, Visual Basic 2005 procura pelo arquivo de chave no diretório que contém a Solução Visual Studio, enquanto o compilador C# procura o arquivo de chave no diretório que contém o binário. Coloque o arquivo de chave no diretório do projeto adequado e defina o atributo de arquivo da seguinte maneira: Visual Basic
Como Incorporar Bibliotecas de Tipo como Recursos Win32 em Aplicativos Baseados no .NET Você pode compactar uma biblioteca de tipos como um arquivo separado ou incorporá-lo como arquivo recurso Win32 dentro de um aplicativo baseado em .NET. O Microsoft Visual Basic 6.0 executado essa tarefa para você automaticamente; no entanto, ao usar Microsoft Visual Basic 2005, você deve incorporar sua biblioteca tipo manualmente. Para incorporar uma biblioteca de tipos como um recurso do Win32 em um aplicativo baseado em .NET 1.
Compilar o aplicativo gerenciado como um arquivo de biblioteca. Por exemplo, para criar um conjunto para um aplicativo chamado MyApp, digite o seguinte comando no prompt de comando: Visual Basic vbc /t:library MyApp.vb
C# csc /t:library MyApp.cs
2.
Exportar um arquivo biblioteca tipo do seu conjunto usando o Tipo Exporter da biblioteca (TlbExp.exe). No prompt de comando, digite o seguinte comando: tlbexp MyApp.dll /out:mytypelib.tlb
3.
Criar um script de recursos que contenha a instrução a seguir: IDR_TYPELIB1 typelib "mytypelib.tlb"
Para este exemplo, o nome de arquivo script é myresource.rc. 4.
Compilar o script usando o Microsoft Windows Resource compiler (Rc.exe). No prompt de comando, digite o seguinte comando: rc myresource.rc
Rc.exe produz ao myresource.res arquivo de recurso. 5.
Compile o arquivo de origem novamente e especifique o arquivo de recurso. No prompt de comando, digite o seguinte comando: Visual Basic vbc /t:library MyApp.vb /win32res:myresource.res
Como Gerar Assemblies de Interoperabilidade Primários Usando Tlbimp.exe A maneira mais simples para produzir conjuntos de interoperabilidade primárias consiste em usar o Importador de Biblioteca de Tipos (TLBIMP.exe). Para gerar um conjunto de interoperabilidade primário usando TLBIMP.exe •
No prompt de comando, digite: tlbimp tlbfile /primary /keyfile:filename /out:assemblyname
Visual C# Consolidado
667
Neste comando, tlbfile é o arquivo que contém a biblioteca de tipos COM, filename é o nome do recipiente ou arquivo que contém o par de chaves e assemblyname é o nome da montagem para entrar com um nome de alta segurança. Conjuntos de interoperabilidade primárias podem referenciar apenas outros conjuntos de interoperabilidade primárias. Se seu conjunto faz referência tipos de uma biblioteca de tipos com de terceiros, você deverá obter um conjunto interoperacional primário do editor antes você pode gerar seu conjunto interoperacional primário. Se você for o editor, você deve gerar um conjunto de interoperabilidade primário para a biblioteca de tipos dependente antes de gerar conjunto de módulos (assembly referência o) de interoperabilidade primária. Primário um conjunto interoperacional dependente com um número de versão que seja diferente da biblioteca de tipos original é não localizável quando instalado no diretório atual. Você deve registrar Principal conjunto interoperacional do dependente no Registro do Windows ou use a /reference Opção para ter certeza que localiza TLBIMP.exe a DLL dependente. Você também poderá dispor várias versões de uma biblioteca de tipos. Para obter instruções, consulte Como Empacotar Várias Versões de Bibliotecas de Tipos. Exemplo O exemplo a seguir importa a biblioteca LibUtil.tlb de tipos COM e assina o conjunto LibUtil.dll com um nome de alta segurança usando o arquivo CompanyA.snk de chave. Omitindo um nome de espaço para nome específico, este exemplo produz o espaço para nome LibUtil padrão. tlbimp LibUtil.tlb /primary /keyfile:CompanyA.snk /out:LibUtil.dll
Para um nome mais descritivo). (usando, o exemplo a seguir substitui o nome de arquivo do conjunto padrão e nome namespace nomeação diretriz. LibraryName o VendorName tlbimp LibUtil.tlb /primary /keyfile:CompanyA.snk /namespace:CompanyA.LibUtil /out:CompanyA.LibUtil.dll
O exemplo a seguir importa MyLib.tlb, quais referências CompanyA.LibUtil.dll, e assina o conjunto CompanyB.MyLib.dll com um nome de alta segurança usando o arquivo CompanyB.snk de chave. Espaço para nome, CompanyB.MyLib,. substitui o nome de espaço para nome padrão tlbimp MyLib.tlb /primary /keyfile:CompanyB.snk /namespace:CompanyB.MyLib /reference:CompanyA.LibUtil.dll /out:CompanyB.MyLib.dll
Como Criar Assemblies de Interoperabilidade Primários Manualmente Uma abordagem menos usada para produzir uma biblioteca de tipos envolve criar um conjunto de interoperabilidade primário manualmente no código fonte, usando uma linguagem que é compatível com o COM comum especificação (cls), como C# idioma. Essa abordagem é útil quando uma biblioteca de tipos não está disponível. Para gerar um conjunto interoperacional primário no código fonte 1.
2.
Crie um conjunto de interoperabilidade no código fonte. Para obter instruções, consulte Criando um wrapper manualmente. Observação Se você deve incluir todos os tipos COM da biblioteca Tipo original quando você cria um conjunto de interoperabilidade primário manualmente. No nível do conjunto, aplicar os seguintes atributos:
Visual C# Consolidado
668
1.
ou AssemblyKeyFileAttributeAssemblyKeyNameAttribute, para especificar o nome do arquivo ou recipiente que contém o par de chaves para usar ao assinar o conjunto com um nome de alta segurança.
2.
GuidAttribute Para especificar o identificador de biblioteca (LIBID) da biblioteca de tipos de destino.
3.
PrimaryInteropAssemblyAttribute Para identificar o conjunto como um conjunto interoperacional primário. Observação Você também pode atrasar assinar um conjunto durante a compilação. Para obter mais informações, consulte Atraso assinatura um conjunto.
3.
O exemplo de código a seguir aplica chamado CompanyA.snk com um arquivo de chave e especifica que este conjunto de módulos (assembly) é um conjunto de interoperabilidade primário suporte versões de biblioteca tipo 4.2 e 5.2. o AssemblyKeyFileAttribute Como mostra o exemplo, você pode dispor mais de uma versão de uma biblioteca tipo Aplicando atributos adicionais conjunto-nível.
Como Gerar Assemblies de Interoperabilidade a partir de Bibliotecas de Tipo O Importador da biblioteca Tipo (TLBIMP.exe) é uma ferramenta de linha de comando que converte o coclasses e interfaces contidos em uma biblioteca de tipos com aos metadados. Essa ferramenta cria um conjunto interoperacional e espaço para nome para as informações tipo automaticamente. Depois os metadados de uma classe estiver disponível, clientes gerenciados podem criar instâncias do tipo COM e chamar seus métodos, apenas como se fosse uma instância .NET. TLBIMP.exe converte uma biblioteca inteira tipo aos metadados de uma vez e não pode gerar informações sobre tipo de um subconjunto dos tipos definidas em uma biblioteca de tipos. Para gerar um conjunto de interoperabilidade de uma biblioteca de tipos •
Use o seguinte comando: TLBIMP < type-library-file> Adicionando a /out: opção produz um conjunto de interoperabilidade com um nome alterada, como LOANLib.dll. Alterar o nome Conjunto interoperacional pode ajudar a distingui-lo da DLL com original e evitar problemas que podem ocorrer tenham nomes duplicados.
Exemplo O seguinte comando produz o conjunto Loanlib.DLL no espaço para nome Loanlib. tlbimp Loanlib.dll
O seguinte comando produz um conjunto de interoperabilidade com um nome alterada (LOANLib.dll). tlbimp LoanLib.dll /out: LOANLib.dll
Visual C# Consolidado
669
Como Gerar Eventos Manipulados por um Coletor COM Se você estiver familiarizado com o modelo baseado em delegate-evento fornecido pelo .NET Framework, não Consulte Manipulando e disparando eventos. Para obter detalhes específicos que se aplicam a este tópico, consulte Disparar um evento na mesma seção. O.NET Framework fornece um sistema baseado em delegate-evento para conectar-se um remetente de evento (origem) a um destinatário de evento (PIA). Quando o coletor é um cliente COM, a origem deve incluir elementos para simular pontos de conexão adicionais. Com essas modificações, um cliente COM pode registrar sua interface do coletor de eventos no modo tradicional chamando o IConnectionPoint::Advise método. (Visual Basic oculta detalhes ponto de conexão, para que não faça precise chamar esses métodos diretamente.) Para interoperar com um coletor de eventos com 1.
Definir a interface do coletor de eventos no código gerenciado. Esta interface pode conter um subconjunto dos eventos sourced por uma classe gerenciado. Os nomes método da interface deve ser a mesma os nomes de eventos.
2.
Do ComSourceInterfacesAttribute aplicar se conectar a interface do coletor de eventos a classe gerenciada.
3.
Exportar o conjunto que contém a classe para uma biblioteca de tipos. Use API equivalente ou Tipo Exporter da biblioteca (TlbExp.exe) um para exportar o conjunto.
4. 5.
Implementar a interface do coletor de eventos em COM. Para clientes com que coletar eventos, implementar a interface do coletor de eventos definido pela fonte de eventos na sua biblioteca de tipos. Usar o mecanismo ponto de conexão para conectar-se a interface do coletor à fonte de eventos.
Exemplo O exemplo a seguir mostra um servidor gerenciado como a origem de eventos e um cliente COM como o coletor de eventos. O servidor gerenciado declara ButtonEvents como uma interface do coletor de eventos e se conecta a interface a Button classe. O cliente não gerenciado cria uma instância da classe Button e implementa a interface do coletor de eventos. Visual Basic ' Managed server (event source) Option Explicit Option Strict Imports System Imports System.Runtime.InteropServices Namespace EventSource Public Delegate Sub ClickDelegate(x As Integer, y As Integer) Public Delegate Sub ResizeDelegate() Public Delegate Sub PulseDelegate() ' Step 1: Defines an event sink interface (ButtonEvents) to be ' implemented by the COM sink. _ Public Interface ButtonEvents Sub Click(x As Integer, y As Integer) Sub Resize() Sub Pulse() End Interface ' Step 2: Connects the event sink interface to a class ' by passing the namespace and event sink interface ' ("EventSource.ButtonEvents, EventSrc"). _ Public Class Button Public Event Click As ClickDelegate Public Event Resize As ResizeDelegate Public Event Pulse As PulseDelegate Public Sub CauseClickEvent(x As Integer, y As Integer) RaiseEvent Click(x, y) End Sub Public Sub CauseResizeEvent() RaiseEvent Resize() End Sub Public Sub CausePulse() RaiseEvent Pulse() End Sub End Class End Namespace using System; using System.Runtime.InteropServices; namespace EventSource { public delegate void ClickDelegate(int x, int y); public delegate void ResizeDelegate(); public delegate void PulseDelegate(); // Step 1: Defines an event sink interface (ButtonEvents) to be // implemented by the COM sink. [GuidAttribute("1A585C4D-3371-48dc-AF8A-AFFECC1B0967") ]
Visual C# Consolidado
670
[InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIDispatch)] public interface ButtonEvents { void Click(int x, int y); void Resize(); void Pulse(); } // Step 2: Connects the event sink interface to a class // by passing the namespace and event sink interface // ("EventSource.ButtonEvents, EventSrc"). [ComSourceInterfaces(GetType(ButtonEvents))] public class Button { public event ClickDelegate Click; public event ResizeDelegate Resize; public event PulseDelegate Pulse; public Button() { } public void CauseClickEvent(int x, int y) { Click(x, y); } public void CauseResizeEvent() { Resize(); } public void CausePulse() { Pulse(); } } } ' COM client (event sink) ' This Visual Basic 6.0 client creates an instance of the Button class and ' implements the event sink interface. The WithEvents directive ' registers the sink interface pointer with the source. Public WithEvents myButton As Button Private Sub Class_Initialize() Dim o As Object Set o = New Button Set myButton = o End Sub ' Events and methods are matched by name and signature. Private Sub myButton_Click(ByVal x As Long, ByVal y As Long) MsgBox "Click event" End Sub Private Sub myButton_Resize() MsgBox "Resize event" End Sub Private Sub myButton_Pulse() End Sub
Como Personalizar Wrappers Invocáveis em Tempo de Execução Há duas maneiras para personalizar um wrapper Callable Runtime (RCW). Se você pode modificar a fonte interface Definition Language (IDL), você pode aplicar atributos de arquivo (tlb) de biblioteca Tipo e importar a biblioteca de tipos Como alternativa, você pode aplicar atributos específicos interop-a tipos importados e gerar um novo conjunto. Suporte para personalizar RCWs padrão é limitado por esses atributos. Para modificar a fonte IDL 1.
Se aplicam atributos TLB a bibliotecas, tipos, membros, e parâmetros. Use a custom palavra-chave e um valor de atributo para alterar metadados. Aplicando atributos TLB, você pode:
o
Especifique o nome de um tipo COM importados, em vez de permitir que o Utilitário de Importação para selecionar o nome de acordo com regras conversão padrão gerenciado.
o
Definir um espaço para nome de destino para os tipos em uma biblioteca com explicitamente.
2. 3.
Compilar o código fonte IDL. Gerar um conjunto do arquivo resultante de biblioteca tipo ou de um arquivo de biblioteca de vínculo dinâmico (DLL) que contém o tipo que pretende implementar.
Para modificar um conjunto importados 1.
Importe o arquivo de biblioteca tipo. Do Importador da biblioteca Tipo (TLBIMP.exe) uso para gerar um conjunto DLL.
2.
Criar um arquivo de texto do conjunto importado usando o Disassembler MSIL (Ildasm.exe).
3. 4.
Aplicar Atributos de interoperabilidade ao arquivo de texto. Gerar um novo conjunto do arquivo de texto modificada usando o Assembler MSIL (Ilasm.exe).
Como Configurar Componentes Baseado em .NET para Habilitar Livre Registro Ativação livre registro-para componentes baseado em .NET é apenas um pouco mais complicado que ele é para componentes COM. A instalação requer dois manifestos: •
Aplicativos COM devem ter um manifesto de aplicativo estilo Win32-para identificar o componente gerenciado.
Visual C# Consolidado
671
•
Componentes baseado em .NET devem ter um manifesto componente para ativação informações necessárias em tempo de execução.
Este tópico descreve como associar um manifesto de aplicativo a um aplicativo; associar um manifesto componente a um componente; e incorporar um manifesto componente em um conjunto. Para criar um manifesto de aplicativo 1. 2.
Usando um editor XML, criar (ou modificar) manifesto de aplicativo pertencentes ao aplicativo do COM que é interoperar com um ou mais componentes gerenciados. Insira o cabeçalho padrão a seguir no início do arquivo:
Para informações sobre elementos manifesto e seus atributos, procure por " Reference Manifests Application " na Biblioteca do MSDN. 3.
Identificar o proprietário do manifesto. No exemplo a seguir, myComApp Versão 1 possui o arquivo de manifesto.
4.
Identificar conjuntos de módulos (assemblies) dependentes. No exemplo a seguir, myComApp depende da myManagedComp.
