Sumário Parte I Princípios básicos do Microsoft.NET Framework Capítulo 1 A arquitetura da plataforma de desenvolvimento.net Framework.............................. 35 Compilando código-fonte em módulos gerenciados.......... 35 Combinando módulos gerenciados em assemblies............ 38 Carregando o Common Language Runtime................. 40 Executando seu código assembly......................... 42 IL e verificação..................................... 49 A.NET Framework Class Library.......................... 50 O Common Type System................................ 53 A Common Language Specification....................... 55 Interoperabilidade com código não-gerenciado.............. 59 Capítulo 2 Construindo, empacotando, implantando e administrando aplicações e tipos................ 63 Objetivos de implantação do.net Framework............... 63 Compilando tipos em um módulo........................ 65 Combinando módulos para formar um assembly............. 72 Adicionando assemblies a um projeto através do IDE do Visual Studio.NET.............................. 78 Utilizando o Assembly Linker.......................... 79 Incluindo arquivos de recurso no assembly............... 81 Informações sobre recursos de versão do assembly........... 81 Números de versão................................. 84 Cultura............................................. 86
14 Sumário Implantação de aplicações descomplicada (assemblies distribuídos privadamente)............................. 87 Controle administrativo descomplicado (configuração)........ 88 Capítulo 3 Assemblies compartilhados....................... 93 Dois tipos de assemblies, dois tipos de implantação........... 94 Criando um nome forte para um assembly.................. 95 O Global Assembly Cache............................... 100 A estrutura interna do GAC........................... 105 Compilando um assembly que referencia um assembly fortemente nomeado................................. 106 Assemblies fortemente nomeados são imunes à adulteração.... 109 Assinatura tardia..................................... 110 Implantando privadamente assemblies fortemente nomeados... 114 Execução lado a lado.................................. 115 Como o runtime soluciona referências a tipos............... 116 Controle administrativo avançado (configuração)............ 119 Controle de diretivas do publicador..................... 124 Reparando uma aplicação defeituosa...................... 126 Parte II Trabalhando com tipos e o Common Language Runtime Capítulo 4 Fundamentos de tipos........................... 133 Todos os tipos são derivados de System.Object............ 133 Conversão (casting) entre tipos........................... 135 Realizando conversão com os operadores is e as do C#..... 137 Os namespaces e os assemblies.......................... 138 Capítulo 5 Tipos primitivos, tipos-referência e tipos-valor........ 145 Tipos primitivos das linguagens de programação............. 145 Operações de tipos primitivos verificadas e não-verificadas.... 149 Tipos-referência e tipos-valor............................ 151 Boxing e unboxing de tipos-valor......................... 157 Capítulo 6 Operações comuns aos objetos.................... 169 Igualdade e identidade de objetos........................ 169 Implementando Equals para um tipo-referência cujas classes base não sobrescrevem Equals de Object....... 170 Implementando Equals para um tipo-referência quando uma ou mais de suas classes base sobrescrevem Equals de Object................................ 172 Implementando Equals para um tipo-valor.............. 173 Resumo da implementação de Equals e dos operadores ==/!=................................. 175 Identidade........................................ 176 Códigos hash de objetos................................ 177 Clonagem de objetos.................................. 179
Sumário 15 Parte III Projetando tipos Capítulo 7 Membros de tipos e sua acessibilidade.............. 185 Membros de tipo..................................... 185 Modificadores de acessibilidade e atributos predefinidos....... 188 Atributos de tipo predefinidos......................... 189 Atributos de campo predefinidos...................... 190 Atributos de método predefinidos...................... 190 Capítulo 8 Constantes e campos........................... 193 Constantes.......................................... 193 Campos............................................ 194 Capítulo 9 Métodos..................................... 197 Construtores de instância............................... 197 Construtores de tipo................................... 203 Métodos de sobrecarga de operadores..................... 206 Operadores e interoperabilidade das linguagens de programação.................................. 208 Métodos de operadores de conversão..................... 211 Passando parâmetros por referência para um método......... 215 Passando um número variável de parâmetros para um método.... 220 Como os métodos virtuais são chamados................... 222 Controle de versão de métodos virtuais.................... 223 Capítulo 10 Propriedades.................................. 229 Propriedades sem parâmetros........................... 229 Propriedades com parâmetros........................... 233 Capítulo 11 Eventos...................................... 239 Projetando um tipo que expõe um evento.................. 240 Projetando um tipo que escuta um evento.................. 245 Controlando explicitamente o registro de eventos............ 247 Projetando um tipo que define muitos eventos.............. 249 Projetando o tipo EventHandlerSet..................... 253 Parte IV Tipos básicos Capítulo 12 Trabalhando com texto.......................... 259 Caracteres........................................... 259 O tipo System.String................................ 262 Construindo strings................................. 262 Strings são imutáveis................................ 264 Comparando strings................................ 265 Internalização de strings............................. 270 Pools de strings.................................... 274 Examinando os caracteres de uma string................. 274 Outras operações com strings......................... 277
16 Sumário Construindo uma string de maneira dinâmica e eficiente....... 278 Construindo um objeto StringBuilder................ 279 Membros de StringBuilder........................ 280 Obtendo uma representação de string para um objeto........ 282 Formatos e culturas específicos........................ 283 Formatando múltiplos objetos em uma única string........ 287 Fornecendo seu próprio formatador personalizado......... 288 Analisando sintaticamente uma string para obter um objeto.... 291 Codificações: convertendo entre caracteres e bytes........... 295 Codificação/decodificação de fluxos de caracteres e bytes... 301 Codificação e decodificação de strings de base 64......... 302 Capítulo 13 Tipos enumerados e flags de bits.................. 305 Tipos enumerados.................................... 305 Flags de bits......................................... 310 Capítulo 14 Arrays....................................... 313 Todos os arrays são implicitamente derivados de System.Array................................... 316 Conversão (casting) de arrays............................ 318 Passando e retornando arrays............................ 319 Criando arrays que têm um limite inferior diferente de zero..... 320 Acesso rápido a array.................................. 321 Redimensionando um array............................. 325 Capítulo 15 Interfaces.................................... 327 Interfaces e herança................................... 327 Projetando uma aplicação que suporta componentes plug-in... 332 Alterando campos em um tipo-valor na forma boxed utilizando interfaces.................................. 334 Implementando múltiplas interfaces que têm o mesmo método.... 336 Implementações explícitas de membros de interface.......... 338 Capítulo 16 Atributos personalizados......................... 345 Utilizando atributos personalizados....................... 345 Definindo seu próprio atributo........................... 349 Construtor de atributos e tipos de dados de campo/propriedade.. 351 Detectando a utilização de um atributo personalizado......... 353 Confrontando duas instâncias de atributo.................. 357 Atributos pseudopersonalizados.......................... 360 Capítulo 17 Delegates.................................... 363 Uma primeira análise sobre delegates..................... 363 Utilizando delegates para métodos de retorno de chamada estáticos........................................... 366 Utilizando delegates para métodos de retorno de chamada de instância........................................ 367 Desmistificando os delegates............................ 368
Sumário 17 Parte V Gerenciando tipos Um pouco da história dos delegates: System.Delegate e System.MulticastDelegate....................... 372 Comparando delegates quanto à igualdade................. 373 Cadeias de delegates.................................. 374 Suporte do C# a cadeias de delegates..................... 378 Obtendo maior controle sobre a chamada de uma cadeia de delegates........................................ 379 Delegates e reflexão................................... 381 Capítulo 18 Exceções..................................... 387 A evolução do tratamento de exceções..................... 388 A mecânica do tratamento de exceções.................... 390 O bloco try...................................... 391 O bloco catch.................................... 391 O bloco finally.................................. 393 O que é exatamente uma exceção?........................ 394 A classe System.Exception........................... 398 Classes de exceção definidas pela FCL...................... 399 Definindo sua própria classe de exceção.................... 402 Como utilizar exceções adequadamente.................... 406 Você não pode ter muitos blocos finally............... 406 Não capture tudo.................................. 407 Recuperando-se satisfatoriamente de uma exceção......... 409 Desfazendo uma operação parcialmente completada quando uma exceção irrecuperável ocorre.............. 409 Ocultando um detalhe de implementação................ 411 O que há de errado com a FCL........................... 413 Considerações de desempenho........................... 415 Filtros de captura..................................... 417 Exceções não-tratadas................................. 420 Controlando o que o CLR faz quando uma exceção não-tratada ocorre................................ 425 Exceções não-tratadas e Windows Forms................ 426 Exceções não-tratadas e Web Forms ASP.NET............. 427 Exceções não-tratadas e Web Services XML ASP.NET........ 428 Rastreamentos de pilhas de exceções...................... 428 Rastreamentos remotos de pilhas...................... 430 Depurando exceções................................... 431 Informando ao Visual Studio que tipo de código depurar.... 434 Capítulo 19 Gerenciamento automático de memória (coleta de lixo)... 437 Entendendo os princípios básicos de trabalhar em uma plataforma com coleta de lixo.......................... 437 O algoritmo de coleta de lixo............................ 441 Finalização.......................................... 444
18 Sumário O que faz com que os métodos Finalize sejam chamados. 450 Como funciona a finalização.......................... 452 O padrão Dispose: forçando a limpeza de um objeto.......... 455 Utilizando um tipo que implementa o padrão Dispose...... 460 Instrução using do C#.............................. 464 Uma interessante questão de dependência............... 465 Referências fracas..................................... 466 Como funciona uma referência fraca.................... 468 Ressurreição......................................... 469 Projetando um pool de objetos utilizando ressurreição...... 471 Gerações............................................ 473 Controle programático do coletor de lixo................... 478 Outras questões sobre o desempenho do coletor de lixo....... 480 Alocações sem sincronização.......................... 482 Coletas paralelas escalonáveis......................... 482 Coletas concorrentes................................ 482 Objetos grandes................................... 484 Monitorando coletas de lixo............................. 484 Capítulo 20 Hospedagem do CLR, AppDomains e reflexão......... 487 Metadados: a pedra fundamental do.net Framework......... 487 Hospedagem do CLR................................... 488 AppDomains......................................... 490 Acessando objetos fora dos limites de um AppDomain...... 493 Eventos de AppDomain.............................. 494 Aplicações e como elas hospedam o CLR e gerenciam AppDomains..................................... 494 Yukon.......................................... 496 A essência da reflexão.................................. 496 Realizando reflexão sobre os tipos de um assembly........... 498 Realizando reflexão sobre os assemblies de um AppDomain.... 500 Realizando reflexão sobre os membros de um tipo: Vinculação..... 501 Carregando assemblies explicitamente..................... 503 Carregando assemblies como arquivos de dados......... 505 Construindo uma hierarquia de tipos derivados de Exception. 506 Descarregando assemblies explicitamente: descarregando um AppDomain..................................... 509 Obtendo uma referência para um objeto System.Type....... 510 Realizando reflexão sobre os membros de um tipo............ 514 Criando uma instância de um tipo...................... 517 Chamando um método de um tipo..................... 518 Vincule uma vez, chame múltiplas vezes................. 522 Realizando reflexão sobre as interfaces de um tipo........... 527 Desempenho da reflexão............................... 529 Índice............................................ 531