Você está na página 1de 15

Prefácio I

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
Prefácio III
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................................................................................................................................
92
Como 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................................................................................................................................1
00
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.............................................................................................................3
63
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......................................................................................................
395
Threads.............................................................................................................................
..........................................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
Prefácio VII
Capítulo 22. Programação . NET e
COM..............................................................................................459
Importação de controles
ActiveX.............................................................................................................................
459
Importação de componentes
COM...............................................................................................................................4
65
Exportação de componentes
.NET................................................................................................................................4
72
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.
Prefácio IX
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 para o 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 infraestrutura
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.
Prefácio XI
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ência em 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.
Prefácio XIII
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, Jonathan Hawkins, 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.