Programando C# - Introdução e Fundamentos

Prévia do material em texto

IPrefácio
Programando C#
Jesse Liberty
TRADUÇÃO DA 4a EDIÇÃO
II Programando C#
Programando C#
Do original Programming C# Copyright © 2006 da Editora Alta Books Ltda.
Authorized translation from English language edition, entitled Programming C#, ISBN 0-596-00699-3, by Jesse
Liberty, published by O’Reilly Media, Inc. Copyright © 2005, 2003, 2002, 2001 by O’Reilly Media, In..
PORTUGUESE language edition published by Editora Alta Books, Copyright © 2006 by Editora Alta Books.
Todos os direitos reservados e protegidos pela Lei 5988 de 14/12/73. Nenhuma parte deste livro, sem autorização
prévia por escrito da editora, poderá ser reproduzida ou transmitida sejam quais forem os meios empregados:
eletrônico, mecânico, fotográfico, gravação ou quaisquer outros. Todo o esforço foi feito para fornecer a mais completa
e adequada informação, contudo a editora e o(s) autor(es) não assumem responsabilidade pelos resultados e usos
da informação fornecida. Recomendamos aos leitores testar a informação, bem como tomar todos os cuidados
necessários (como o backup), antes da efetiva utilização. Este livro não contém CD-ROM, disquete ou qualquer
outra mídia.
Erratas e atualizações: Sempre nos esforçamos para entregar a você, leitor, um livro livre de erros técnicos ou de
conteúdo; porém, nem sempre isso é conseguido, seja por motivo de alteração de software, interpretação ou
mesmo quando alguns deslizes constam na versão original de alguns livros que traduzimos. Sendo assim, criamos
em nosso site, www.altabooks.com.br, a seção Erratas, onde relataremos, com a devida correção, qualquer erro
encontrado em nossos livros.
Avisos e Renúncia de Direitos: Este livro é vendido como está, sem garantia de qualquer tipo, seja expressa ou
implícita.
Marcas Registradas: Todos os termos mencionados e reconhecidos como Marca Registrada e/ou comercial são
de responsabilidade de seus proprietários. A Editora informa não estar associada a nenhum produto e/ou fornecedor
apresentado no livro. No decorrer da obra, imagens, nomes de produtos e fabricantes podem ter sido utilizados, e
desde já a Editora informa que o uso é apenas ilustrativo e/ou educativo, não visando ao lucro, favorecimento ou
desmerecimento do produto/fabricante.
Produção Editorial Editora Alta Books
Coordenação Editorial: Fernanda Silveira
Tradução: Betina Macêdo, Weuler Gonçalves e Aldir José Coelho
Revisão: Patrícia Veloso
Diagramação: Fernanda Silveira
Impresso no Brasil
O código de propriedade intelectual de 1º de Julho de 1992 proíbe expressamente o uso coletivo sem autorização
dos detentores do direito autoral da obra, bem como a cópia ilegal do original. Esta prática generalizada nos
estabelecimentos de ensino, provoca uma brutal baixa nas vendas dos livros a ponto de impossibilitar os autores
de criarem novas obras.
Av. Nilo Peçanha, 155, cjs. 1101 a 1106 - Castelo Rio de Janeiro – RJ.
CEP: 20020-100
Tel: 21 2532-6556/ Fax: 2215-0225
www.altabooks.com.br
e-mail: altabooks@altabooks.com.br
IIIPrefácio
Sumário
Prefácio.......................................................................................................................8
Parte I. A Linguagem C#............................................................................................1
Capítlo 1. C# e o .NET Framework................................................................................................................3
A plataforma .NET.......................................................................................................................................................3
O .NET Framework ......................................................................................................................................................3
A compilação e a MSIL...................................................................................................................................................5
A linguagem C#.............................................................................................................................................................5
Capítulo 2. Como Começar: “Hello World”..................................................................................................7
Classes, objetos e tipos..................................................................................................................................................7
Como utilizar o depurador do Visual Studio .NET..........................................................................................................15
Capítulo 3. Fundamentos da Linguagem C#..............................................................................................19
Tipos...............................................................................................................................................................................19
Variáveis e constantes......................................................................................................................................................23
Expressões.......................................................................................................................................................................29
Espaço em branco..........................................................................................................................................................29
Declarações..................................................................................................................................................................30
Operadores.....................................................................................................................................................................42
Diretivas de pré-processador.............................................................................................................................................50
Capítulo 4. Classes e Objetos.......................................................................................................................53
A definição de classes....................................................................................................................................................53
A criação de objetos.......................................................................................................................................................57
O uso de membros estáticos............................................................................................................................................63
A destruição de objetos.....................................................................................................................................................66
A passagem de parâmetros..........................................................................................................................................69
Sobrecarga de métodos e construtores............................................................................................................................73
Encapsulamento de dados com as propriedades.............................................................................................................76
Capítulo 5. Herança e Polimorfismo............................................................................................................81
Especialização e generalização..........................................................................................................................................81
Polimorfismo.......................................................................................................................................................................83
IV Programando C#
Classes abstratas..............................................................................................................................................................89
A raiz de todas as classes: Object................................................................................................................................92Como fazer boxing e unboxing de tipos..........................................................................................................................93
Aninhamento de classes...............................................................................................................................................95
Capítulo 6. Sobrecarga de Operador.........................................................................................................99
O uso da palavra-chave operator........................................................................................................................................99
Suporte a outras linguagens do .NET................................................................................................................................100
Criação de operadores úteis..........................................................................................................................................100
Pares lógicos..................................................................................................................................................................100
O operador de igualdade..................................................................................................................................................100
Operadores de conversão.................................................................................................................................................101
Capítulo 7. Structs........................................................................................................................................107
A definição das structs....................................................................................................................................................107
A criação de structs.....................................................................................................................................................109
Capítulo 8. Interfaces.................................................................................................................................113
A definição e a implementação de uma interface............................................................................................................114
O acesso a métodos de interfaces....................................................................................................................................121
Anule implementações de interface.................................................................................................................................127
Implementação explícita de interface...............................................................................................................................130
Capítulo 9. Arrays, Indexadores e Coleções............................................................................................139
Arrays.......................................................................................................................................................................139
A declaração foreach....................................................................................................................................................143
Indexadores.................................................................................................................................................................155
Interfaces de coleção................................................................................................................................................162
Restrições.......................................................................................................................................................................165
List<T>.......................................................................................................................................................................169
Pilhas........................................................................................................................................................................181
Dicionários...............................................................................................................................................................183
IDictionary<K,V>.......................................................................................................................................................184
Capítulo 10. Strings e Expressões Regulares......................................................................................187
Strings...................................................................................................................................................................187
Expressões regulares....................................................................................................................................................200
VI Programando C#
Capítulo 16. Como Juntar Tudo...............................................................................................................317
O design geral.............................................................................................................................................................312
Criação do Web Services Client......................................................................................................................................327
Exibição da saída......................................................................................................................................................334
Pesquisa por Categoria.............................................................................................................................................342
Parte III. CLR e Framework .NET............................................................................347
Capítulo 17. Assemblies e Versões..........................................................................................................349
Os assemblies multimódulos...........................................................................................................................................351
Os assemblies privados...................................................................................................................................................356
Assemblies compartilhados.............................................................................................................................................357
Outros assemblies necessários....................................................................................................................................361
Capítulo 18. Atributos e Reflexão.............................................................................................................363
Os atributos.................................................................................................................................................................363
Reflexão.....................................................................................................................................................................368
Capítulo 19. Ordenação e Remoting....................................................................................................377
Domínios de aplicações..............................................................................................................................................378
Contexto..................................................................................................................................................................385
Remoting..................................................................................................................................................................387
Capítulo 20. Threads e Sincronização......................................................................................................395Threads.......................................................................................................................................................................395
Sincronização.................................................................................................................................................................402
Condições de disputa e impasses.....................................................................................................................................411
Capítulo 21. Fluxos.................................................................................................................................413
Arquivos e diretórios...................................................................................................................................................413
Criação de um objeto DirectoryInfo.............................................................................................................................413
Leitura e gravação de dados.......................................................................................................................................422
O trabalho com arquivos de texto..................................................................................................................................426
E/S assíncrona............................................................................................................................................................428
E/S de rede.............................................................................................................................................................432
Fluxos da Web.............................................................................................................................................................447
Serialização..................................................................................................................................................................449
VIIPrefácio
Capítulo 22. Programação . NET e COM..............................................................................................459
Importação de controles ActiveX.............................................................................................................................459
Importação de componentes COM...............................................................................................................................465
Exportação de componentes .NET................................................................................................................................472
APÊNDICE: Palavras-chave da Linguagem C#....................................................................................481
VIII Programando C#
Prefácio
Aproximadamente a cada dez anos aparece uma nova tecnologia para mudar a maneira como vemos o desenvolvimento de
aplicações. No início dos anos 80, as novas tecnologias eram o Unix, que podia ser executado em uma estação de trabalho,
e uma nova e poderosa linguagem chamada C, desenvolvida pela AT&T. O início dos anos 90 trouxe o Windows e o C++.
Cada desenvolvimento representou uma mudança de maré na maneira como abordávamos a programação. Em 2000, o
.NET e o C# foram a próxima onda, e o .NET 2.0 completa a transição.
A Microsoft “apostou a empresa” no .NET. Quando uma empresa desse tamanho e influência gasta bilhões de dólares e
reorganiza toda sua estrutura para suportar uma nova plataforma, os programadores tomam conhecimento disso. Acontece
que o .NET representa uma enorme mudança na maneira como você pensa na programação. É, em resumo, uma nova
plataforma de desenvolvimento criada para facilitar o desenvolvimento orientado a objeto para a Internet. A linguagem de
programação escolhida para essa plataforma é o C#, estruturada a partir das lições aprendidas com o C (alto desempenho),
C++ (estrutura orientada a objeto), Javatm (coleta de lixo, segurança alta) e Visual Basic (desenvolvimento rápido) para criar
uma nova linguagem, idealmente pronta para o desenvolvimento de aplicações para web baseadas em componente e
distribuídas em n-camadas.
O C# 2.0, linguagem escolhida para o .NET 2005, vem com ferramentas atualizadas e um novo e poderoso ambiente de
desenvolvimento. É o feito que coroa o investimento em pesquisa e desenvolvimento feito pela Microsoft. É uma ferramenta
excelente.
Sobre este livro
Este livro é um tutorial de C# e sobre como escrever aplicações .NET com C#.
Se você for um programador de C# 1.1 experiente e tudo o que deseja saber é o que há de novo no C# 2.0, largue este livro
e compre Visual C# 2005: A Developer’s Notebook (O’Reilly Media, Inc.).
Se, por outro lado, você deseja dar uma refrescada em suas habilidades no C#, ou é experiente em outra linguagem de
programação como C++ ou Java, ou mesmo se essa for a sua primeira linguagem de programação, então este livro foi feito
para você.
Do que você precisa para utilizar este livro
Começando pela versão Beta do Visual Studio Whidbey (2005), a Microsoft facilitou o acesso ao trabalho que está em
progresso. Há várias opções disponíveis: assim como o Visual Studio possui várias opções, as versões de pré-lançamento do
.NET 2.0 e do Visual Studio 2005 são oferecidas de várias maneiras:
Download do SDK
O SDK Beta, que inclui compiladores de linha de comando, documentação e outras ferramentas, está disponível para
download gratuito em http://msdn.microsoft.com/netframework/downloads/updates/default.asp. É um arquivo pequeno,
mas você precisa utilizar seu próprio editor de código (qualquer coisa serve, desde o Bloco de Notas até o SharpDevelop).
Edições Expressas
A Microsoft lançou versões separadas do Visual Studio em pequenos downloads para que você consiga instalar e
trabalhar com ele rapidamente. É possível fazer o download das Edições Expressas em http://lab.msdn.microsoft.com/
vs2005/. Utilize o Visual C# Express na maioria dos exemplos deste livro. Você precisará do Visual Web Developer
Express para alguns dos exemplos, e precisará instalar o SQL Server Express ou MSDE (Microsoft Data Engine) para
alguns dos exemplos do ADO.NET.
IXPrefácio
Preview Beta e para a Comunidade de Tecnologia
A Microsoft também disponibilizou para download versões completas do Visual Studio 2005. Elas vêm em duas
formas: Preview para a Comunidade de Tecnologia (CTP), que de alguma forma são versões pouco lapidadas, e
versões beta com muitos enfeites. No momento em que eu estava escrevendo este livro, os CTPs estavam disponíveis
aos assinantes do MSDN nas versões Visual Studio Professional, Standard e Team System. O Beta 1 do Visual Studio
Professional também está disponível para assinantes MSDN e para os não-assinantes, pelo custo da entrega. Para
obter mais informações, consulte http://lab.msdn.microsoft.com/vs2005/get/default.aspx.
Mono
O Projeto Mono é uma plataforma de desenvolvimento aberto baseado em .NET. É patrocinado pela Novell e é
executado em Linux, Mac OS X e outros sistemas operacionais. Apesar de a versão atual estar direcionada para .NET
1.1, você pode escolher sua instalação com suporte a alguns recursos do .NET 2.0. Para mais informações, consulte
http://www.mono-project.com/about/index.html.
A tradução da quarta edição de Programando C# funcionará com qualquer um desses ambientes. Entretanto, como cada um
está em um nível de versão ligeiramente diferente, algumas telas podem ser diferentes do que você vê. Em resumo, sua
milhagem poderá variar.
Como este livro está organizado
A Parte I concentra-se nos detalhes da linguagem, a Parte II discute como escrever programas .NET e a Parte III descreve o
uso do C# com o Tempo de Execução de Linguagem Comum do .NET e com a Biblioteca de Classes do Framework.
Parte I, a linguagem C#
O Capítulo 1, C# e o .NET Framework, apresenta a você a linguagem C# e a plataforma .NET.
O Capítulo 2, Como começar: “Hello World”, demonstra um programa simples para fornecer um contexto parao que vier a
seguir, e apresenta a você o IDE do Visual Studio e alguns conceitos da linguagem C#.
O Capítulo 3, Fundamentos da linguagem C#, apresenta o básico da linguagem, de tipos de dados internos a palavras-chave.
As classes definem novos tipos e permitem que o programador estenda a linguagem para que possa modelar melhor o
problema que tenta solucionar. O Capítulo 4, Classes e objetos, explica os componentes que formam o corpo e a alma do C#.
As classes podem ser representações e abstrações complexas de coisas que existem no mundo real. O Capítulo 5, Herança
e polimorfismo, discute como as classes se relacionam e interagem.
O Capítulo 6, Sobrecarga de operador, ensina a você como adicionar operadores a seus tipos definidos pelo usuário.
Os Capítulos 7 e 8 introduzem as Structs e Interfaces respectivamente, ambas primas muito próximas das classes. As
estruturas são objetos superficiais mais restritos do que as classes e fazem menos solicitações ao sistema operacional e à
memória. As interfaces são contratos: descrevem como uma classe funcionará para que os outros programadores possam
interagir com seus objetos de uma maneira bem definida.
Os programas orientados a objeto podem criar muitos objetos. Quase sempre é conveniente agrupá-los e manipulá-los em
conjunto, e o C# fornece amplo suporte a coleções. O Capítulo 9, Arrays, indexadores e coleções, explora as classes de
coleção fornecidas na Biblioteca de Classes do Framework, as novas coleções genéricas (Generic) e mostra como criar seus
próprios tipos de coleção utilizando as genéricas.
O Capítulo 10, Strings e expressões regulares, discute como você poderá utilizar o C# para manipular strings de texto e
expressões regulares. A maioria dos programas do Windows e da Web interage com o usuário, e as strings representam um
papel vital na interface com o usuário.
O Capítulo 11, Como manipular exceções, explica como se deve lidar com as exceções e fornece um mecanismo orientado
a objeto para que você possa lidar com as pequenas emergências da vida.
X Programando C#
Tanto as aplicações do Windows como as da Web são orientadas a evento. No C#, os eventos são membros da primeira
classe da linguagem. O Capítulo 12, Delegados e eventos, concentra-se em como os eventos são gerenciados e como os
delegados (mecanismos de callback independentes de tipo orientados a objeto) são utilizados para suportarem a manipulação
de eventos.
Parte II, Como Programar com o C#
A Parte II detalha como escrever programas .NET: tanto aplicações para desktop com Formulários Windows quanto aplicações
para web com Formulários Web. Além disso, descreve a interatividade com bancos de dados e como criar serviços web.
No topo da infra-estrutura do .NET está uma abstração de alto nível do sistema operacional, criado para facilitar o desenvolvimento
de software orientado a objeto. Essa camada superior inclui o ASP.NET e os Windows Forms. O ASP.NET inclui tanto os Web
Forms, para um desenvolvimento rápido de aplicações web, quanto os serviços web, para a criação de objetos web sem
interface com o usuário. Um serviço para web é uma aplicação distribuída que fornece funcionalidade através de protocolos
web padrão, mais comumente XML e HTTP.
O C# fornece um modelo de Desenvolvimento Rápido de Aplicações (RAD), similar ao previamente disponível apenas no
Visual Basic. O Capítulo 13, Criação de aplicações Windows, descreve como utilizar esse modelo RAD para criar programas
Windows de qualidade profissional utilizando o ambiente de desenvolvimento Windows Forms.
Seja para Web ou para o desktop, a maioria das aplicações depende da manipulação e do gerenciamento de grandes
quantidades de dados. O Capítulo 14, Acesso aos dados com o ADO.NET, explica a camada ADO.NET do .NET Framework e
a interação com o Microsoft SQL Server e outros provedores de dados.
O Capítulo 15, A programação de aplicações ASP.NET e serviços web, concentra-se nas duas partes da tecnologia ASP.NET:
Web Forms e Web Services.
O Capítulo 16, Como juntar tudo, combina um número de habilidades ensinadas na Parte II para mostrar a você como
construir um conjunto de aplicações integradas.
Parte III, o CLR e o .NET Framework
Um tempo de execução é um ambiente onde os programas são executados. O Tempo de Execução de Linguagem Comum
(CLR) é o coração do .NET. Inclui um sistema de digitação de dados imposto através da plataforma e que é comum a todas
as linguagens desenvolvidas para o .NET. O CLR é responsável por processos como o gerenciamento da memória e a
contagem de referência de objetos.
Outro recurso fundamental do CLR do .NET é a coleta de lixo. Ao contrário da programação C/C++ tradicional, em C# o
desenvolvedor não é responsável pela destruição dos objetos. Incontáveis horas gastas na procura de vazamentos de
memória são coisa do passado; o CLR é limpo quando seus objetos não estiverem mais em uso. O coletor de lixo do CLR
verifica a pilha procurando por objetos não referenciados e libera a memória utilizada por eles.
A plataforma .NET e a biblioteca de classes se estendem até a plataforma de nível médio, onde você encontra uma infra-
estrutura de classes de suporte, incluindo tipos para a comunicação de interprocessos, XML, threading, E/S, segurança,
diagnósticos, etc. A camada média também inclui os componentes de acesso de dados, coletivamente chamados de ADO.NET.
A Parte III deste livro discute o relacionamento do C# com o CLR e a Biblioteca de Classes do Framework.
O Capítulo 17, Assemblies e versões, faz uma distinção entre os assemblies privados e os públicos e descreve como eles são
criados e gerenciados. No .NET, um assembly é uma coleção de arquivos que aparece para o usuário como uma única
biblioteca de vínculo dinâmico (DLL) ou arquivo executável. Um assembly é a unidade básica da reutilização, versão, segurança
e organização.
Os assemblies do .NET incluem um amplo metadado sobre classes, métodos, propriedades, eventos e assim por diante. Esse
metadado é compilado em um programa e recuperado programaticamente através de reflexão. O Capítulo 18, Atributos e
reflexão, explica como adicionar um metadado a seu código, como criar atributos personalizados e como acessar esse
metadado através da reflexão. Continua a discutir o chamado dinâmico, no qual os métodos são chamados com binding
(tempo de execução) tardio.
XIPrefácio
O .NET Framework foi criado para suportar aplicações distribuídas e baseadas em web. Os componentes criados em C#
podem residir dentro de outros processos na mesma máquina ou em outra máquina da rede, ou ainda em outro local na
Internet. Marshaling ou ordenação é a técnica de interação com os objetos que não estejam realmente no local, enquanto
que remoting compreende técnicas de comunicação com tais objetos. O Capítulo 19, Ordenação e remoting, faz uma
descrição mais elaborada.
A Biblioteca de Classes do Framework fornece amplo suporte para a E/S assíncrona e outras classes que tornem desnecessária
a explícita manipulação de threads. Entretanto, o C# não fornece suporte para Threads e sincronização, discutidos no Capítulo
20.
O Capítulo 21 trata de Fluxos, um mecanismo não somente para a interação com o usuário, mas também para a recuperação
de dados da Internet. Esse capítulo inclui uma cobertura completa do suporte do C# à serialização: a capacidade de escrever
um objeto gráfico para o disco e ler tal objeto novamente.
O Capítulo 22, Programação .NET e COM, explora a interoperabilidade, a capacidade de interagir com componentes COM
criados fora do ambiente do .NET Framework. É possível chamar componentes de aplicações C# para o COM e chamar
componentes do COM para C#. O Capítulo 22 descreve como isso é feito.
Concluímos o livro com um apêndice de palavras-chave do C#.
Para quem este livro foi feito
A quarta edição do Programming C# foi escrita para programadores que desejam desenvolver aplicações para a plataforma
.NET. Não há dúvida de que muitos de vocês já possuem experiência em C++, Java ou Visual Basic (VB). Outros leitores
podem ter experiênciaem outras linguagens de programação, e alguns podem não ter experiência específica em programação,
mas talvez estejam trabalhando com HTML e outras tecnologias web. Este livro foi escrito para todos vocês, mas, se você não
possui experiência nenhuma em programação, pode encontrar alguma dificuldade.
Se você estiver migrando do C, C++, VB 6 ou Java, as seções a seguir devem mostrar algumas comparações básicas com o
C#. O mais importante de tudo é ficar de olho nas observações feitas no livro especificamente para você.
C# 2.0 x C# 1.1
Houve muitas mudanças no C#, ambiente de desenvolvimento e no .NET Framework desde a versão 1.1. Todas foram
criadas para minimizar seu trabalho de “encanador” quando estiver escrevendo e para ajudá-lo a concentrar-se na construção
de aplicações robustas.
Este livro integra as alterações e não pretende ser um guia para o programador de C# 1.1 experiente que esteja procurando
somente as alterações no C# 2.0. Isso posto, eu realmente tentarei apontar o que há de novo no C# 2.0 à medida que
avançarmos.
C# x Visual Basic .NET
A premissa do .NET Framework é que todas as linguagens são criadas para serem iguais. Parafraseando George Orwell,
entretanto, algumas linguagens são mais iguais do que outras. O C# é uma excelente linguagem para o desenvolvimento
.NET. Você descobrirá que ela é extremamente versátil, robusta e bem desenhada. Também é atualmente a linguagem
utilizada com mais freqüência em artigos e tutoriais sobre a programação .NET.
É possível que muitos programadores de VB 6 decidam aprender C# em vez de atualizar suas habilidades para o VB.NET. A
transição do VB 6 para o VB.NET é, inegavelmente, quase tão difícil quanto a do VB 6 para o C#, e, justo ou não, historicamente
a família de programadores de C possui um potencial de ganhos salariais maior do que os programadores de VB. Como um
problema prático, os programadores de VB nunca tiveram o respeito ou os salários que mereciam, e o C# oferece uma
maravilhosa oportunidade de fazer uma transição potencialmente lucrativa.
De qualquer forma, se você tiver experiência em VB, seja bem-vindo! Este livro foi feito com você em mente também, e tentei
tornar a conversão mais fácil.
XII Programando C#
C# x Java
Os programadores de Java podem olhar para o C# com uma mistura de tremedeira, divertimento e rancor. Foi sugerido que
o C# seria, de alguma forma, um “pedaço arrancado” do Java. Não farei comentários sobre a guerra religiosa entre a
Microsoft e “qualquer um menos a Microsoft”, exceto para admitir que o C# certamente aprendeu muito com o Java. Mas
então o Java também aprendeu muita coisa com o C++, que deve sua sintaxe ao C, que por sua vez foi criado a partir de
lições aprendidas com outras linguagens. Somos todos vencedores.
O C# oferece uma fácil transição para os programadores de Java: a sintaxe é muito similar e a semântica é familiar e
confortável. Os programadores de Java provavelmente desejarão concentrar-se nas diferenças entre o Java e o C# para
utilizar a linguagem C# de maneira efetiva. Tentei fornecer uma série de marcadores pelo caminho (consulte as observações
feitas aos programadores de Java dentro dos capítulos).
C# x C e C++
Enquanto é possível programar em .NET com C e C++, isso não é fácil ou natural. Francamente, tendo trabalhado por dez
anos como programador C++ e escrito uma dúzia de livros sobre o assunto, prefiro ter meus dentes obturados a trabalhar
com C++ gerenciado. Talvez seja porque o C# é muito mais amigável. De qualquer maneira, quando vi o C#, nunca mais olhei
para trás.
Tenha cuidado, porém; há um grande número de pequenas armadilhas pelo caminho, e fui cuidadoso o bastante para marcá-
las com luzes piscantes e cones laranja.
Convenções utilizadas neste livro
As seguintes convenções de fontes serão utilizadas neste livro:
O Itálico é usado em:
Nomes de caminhos, nomes de arquivos e nomes de programa.
Endereços de Internet, como nomes de domínio e URLs.
Novos termos no local onde são definidos.
A fonte Courier é usada em:
Linhas de comando e opções que devam ser digitadas textualmente.
Nomes e palavras-chave em exemplos de programa, incluindo nomes de métodos, nomes de variáveis e nomes de
classes.
A fonte Courier em itálico é usada em:
Itens que podem ser substituídos, como variáveis e elementos opcionais, dentro de linhas de sintaxe ou de código.
A fonte Courier em negrito é usada para:
Enfatizar um trecho de código.
Preste bem atenção nas observações destacadas do texto com os seguintes ícones:
Esta é uma dica. Contém informações adicionais muito úteis sobre o tópico em questão.
Este é um aviso. Ajuda a resolver e evitar problemas que podem incomodar.
XIIIPrefácio
Suporte
Como parte de minhas responsabilidades como autor, forneço um suporte contínuo de meus livros através do meu website:
http://www.LibertyAssociates.com
Você também poderá obter o código-fonte de todos os exemplos de Programming C# em meu site, onde terá acesso ao
grupo de discussão sobre o livro e encontrará uma seção separada para perguntas sobre o C#. Antes de enviar uma
pergunta, entretanto, consulte o FAQ (Frequently Asked Questions – Perguntas Freqüentes) e os arquivos de errata. Se você
verificar esses arquivos e ainda tiver uma pergunta, siga adiante e a envie para o centro de discussão.
A maneira mais efetiva de obter ajuda é fazendo uma pergunta muito precisa ou mesmo criando um pequeno programa que
ilustre sua área de preocupação ou dúvida. Também é possível que você queira consultar os vários grupos e centros de
discussão disponíveis na Internet. A Microsoft oferece um grande número de grupos de discussão, e o DevelopMentor (http:/
/discuss.develop.com) possui maravilhosas listas de discussão por e-mail sobre .NET.
Gostaríamos de ouvir um pouco sobre você
Testamos e verificamos as informações contidas neste livro o máximo que pudemos, mas talvez alguns recursos estejam
diferentes (ou mesmo tenhamos cometido um erro!). Por favor, avise-nos de qualquer erro que venha a encontrar e envie-nos
suas sugestões para futuras edições ao escrever para(em inglês):
O’Reilly Media, Inc.
1005 Gravenstein Highway North
Sebastopol, CA 95472
(707) 829-0515 (internacional ou local)
Possuímos uma página web feita para o livro, que lista exemplos e quaisquer planos de edições futuras. É possível acessar
tais informações em:
http://www.oreilly.com/catalog/progcsharp4
Para fazer comentários ou perguntas técnicas sobre este livro, envie um e-mail para:
bookquestions@oreilly.com
Para obter mais informações sobre nossos livros, conferências, Centros de Recursos e sobre a Rede O´Reilly, assim como
artigos técnicos e discussões adicionais sobre o C# e o .NET Framework, consulte nosso website:
http://www.oreilly.com
E o ONDotnet da O´Reilly (em inglês):
http://www.ondotnet.com
Safari Enabled
Quando você enxergar o ícone Safari Enabled na capa de seu livro de tecnologia favorito,
significa que o livro está disponível na forma on-line através do O´Reilly Network Safari
Bookshelf (Prateleira Safari da Rede O´Reilly).
O Safari oferece uma solução melhor do que os livros eletrônicos. É uma biblioteca virtual
que permite a você procurar com facilidade vários dos melhores livros técnicos, recortar e
colar exemplos de código, fazer download de capítulos e encontrar respostas rápidas quando precisar das informações mais
atualizadas e exatas. Ele é de graça e pode ser acessado em http://safari.oreilly.com.
XIV Programando C#
Agradecimentos
Antes de dizer qualquer coisa, preciso fazer um agradecimento especial a Ian Griffiths, que fez várias edições técnicas e
ofereceu sua experiência e é um dos caras mais bacanas e inteligentes que eu conheço.
Esta é a tradução da quarta edição de Programando C#, e muitos amigos e leitores me ajudaram a melhorá-lo. Não é
possível dizer todos os nomes, mas eu devo fazer uma menção especial a Donald Xie, Dan Hurwitz, Seth Weiss, Sue Lynch,
Cliff Gerald, Tom Petr, Jim Culbert, Mike Woodring, Eric Gunnerson, Rob Howard, Piet Obermeyer, JonathanHawkins, Peter
Drayton, Brad Merrill, Ben Albahari, Susan Warren, Brian Bischof e Kent Quirk.
John Osborn me apresentou à O´Reilly, com quem sempre estarei em dívida. Valerie Quercia, Claire Cloutier e Tatiana Diaz
fizeram um tremendo trabalho nas versões anteriores, e a atualização para o C# 2.0 foi guiada por Brian Jepson. Rob Romano
criou várias ilustrações e melhorou outras. Tim O´Reilly forneceu apoio e recursos, e eu estou muito grato.
Muitos leitores têm escrito para apontar erros gráficos e alguns errinhos nas primeiras três edições. Agradecemos seu
esforço, com menção especial a Peter Adams, Sol Bick, Brian Cassel, Steve Charbonneau, Ronald Chu, John Corner, Duane
Corpe, Kevin Coupland, Randy Eastwood, Glen Fischer, Larry Fix, Andy Gaskall, Dave Fowler, Vojimir Golem, David Kindred,
Steve Kirk, Bob Kline, Theron LaBounty, Aron Landy, Jeremy Lin, Chris Linton, Mark Melhado, Harry Martyrossian, Jason
Mauss, Stephen Nelson, Harold Norris, Tim Noll, Mark Phillips, Marcus Rahilly, Paul Reed, Christian Rodriguez, David Solum,
Paul Schwartzburg, Erwing Steininger, Fred Talmadge, Steve Thomson, Greg Torrance, Ted Volk, John Watson, Walt White e Seen
Sai Yang.
Trabalhamos duro para corrigir todos esses erros nesta quarta edição. Percorremos todo o livro para assegurar-nos de que
novos erros não tinham sido adicionados, e que todos os códigos conseguiam ser compilados e executados apropriadamente
com o Visual Studio 2005. Isso posto, se você ainda encontrar algum erro, por favor verifique a errata em meu website (http:/
/www.LibertyAssociates.com) e, se o seu erro for novo, envie um e-mail para jliberty@libertyassociates.com.