Você está na página 1de 20

Sumrio

O que h de novo no C# 3.0 1 O primeiro programa em C# Compilao Identificadores e palavras-chaves Literais, marcadores de pontuao e operadores Comentrios Exemplos de tipos predefinidos Membros de um tipo Converses Tipos de valor versus Tipos de referncia Taxonomia de tipos predefinidos Literais numricos Converses numricas Operadores aritmticos Operadores de acrscimo e descrscimo Operaes especializadas em integrais Inteiros de 8 e 16 bits Valores especiais de float e double double versus decimal Erros de arredondamento de nmeros reais Sintaxe 4 7 7 8 9 10 10 11 12 14 15 18 19 20 21 22 23 23 24 25 26 26

Conceitos bsicos de tipos

Tipos numricos

Sumrio | iii

Tipos e operadores booleanos


iv

27 27 28 29 30 30 32 33 34 36 37 37 38 39 40 40 44 45 46 46 47 48 49 50 50 51 51 55

Operadores de igualdade e comparao Operadores condicionais Converses char Tipo de string Inicializao de elemento padro Arrays multidimensionais Expresses simplificadas de inicializao de array Verificao de limites Pilha e Heap Atribuio definitiva Valores padro Parmetros var: Variveis locais tipificadas implicitamente (C# 3.0) Expresses primrias Expresses void Expresses de atribuio Precedncia e associatividade dos operadores Tabela de operadores Instrues de declarao Instrues de expresso Instrues de seleo Instrues de iterao
| Guia de Bolso: C# 3.0

Strings e Caracteres

Arrays

Variveis e parmetros

Expresses e operadores

Instrues

Instrues de salto Instrues variadas A diretiva using Regras dentro de um namespace Alias (apelidos) de tipos e namespaces Campos Mtodos Construtores de instncia Inicializadores de objeto (C# 3.0) A referncia this Propriedades Indexadores Constantes Construtores estticos Classes estticas Finalizadores Classes e mtodos parciais Polimorfismo Casting (declarao) Funes-membro virtuais Classes e membros abstratos Como ocultar membros herdados Como isolar funes e classes A palavra-chave base Construtores e herana Sobrecarga e resoluo

56 58 58 60 60 61 62 62 62 63 66 66 67 69 70 71 72 73 73 74 75 75 77 78 78 79 79 80 81

Namespace

Classes

Herana

Sumrio | v

O tipo object Boxing e Unboxing Verificao esttica e dinmica de tipos Listagem de membros de objeto GetType() e typeof Equals, ReferenceEquals e GetHashCode O mtodo ToString Semnticas de construo da struct Exemplos Limitao da acessibilidade Restries aos modificadores de acesso Extenso de interfaces Implementao explcita de interface Implementao virtual de membros de interface Reimplementao de interface em uma subclasse Converses de enums Enumeraes com Flags Operadores para enums

82 83 84 84 84 85 86 87 87 88 89 89 89 90 91 91 92 93 94 95 96 97 97 98 98 99 100 101 102

Structs Modificadores de acesso

Interfaces

Enums

Tipos aninhados Genricos


vi

Tipos genricos Por que os genricos existem? Mtodos genricos Declarao de parmetros genricos Typeof e os genricos
| Guia de Bolso: C# 3.0

O valor genrico default Restries genricas Genricos e covarincia Subclasses de tipos genricos A auto-referncia das declaraes genricas Dados estticos Inicializao da coleo genrica Como criar mtodos para plug-ins com delegates Delegates multicast Instncia versus Mtodo esttico Target T ipos delegate genricos Compatibilidade dos delegates Modelo padro de eventos Acessores de evento Modificadores de evento Especificao explcita de tipos de parmetros Lambda Expresses Lambda genricas e os delegates Func Variveis externas

102 103 104 105 106 106 106 107 108 108 109 109 109 112 113 116 117 117 119 119 120 121 122 124 125 126 128

Delegates

Eventos

Expresses Lambda (C# 3.0)

Mtodos annimos Instrues try e excees A clusula catch O bloco finally Acionamento de excees Tipos comuns de exceo

Sumrio | vii

Enumerao e iteradores Enumerao Iteradores Semntica dos iteradores Combinao das seqncias Conceitos bsicos de Null Operadores lifted (levantados) bool? Operadores de aglutinao Null Funes operadoras Sobrecarga dos operadores de igualdade e de comparao Converses implcitas e explcitas personalizadas Encadeamento do mtodo de extenso Ambigidade e resoluo

129 129 130 132 133 135 135 136 138 138 138 139 140 141 142 143 143 144 145 146 150 151 155 156 159 160 160 162

Tipos Nullable

Sobrecarga de operadores

Mtodos de extenso (C# 3.0)

Tipos annimos (C# 3.0) LINQ (C# 3.0) Princpios bsicos do LINQ Execuo diferida Operadores de consulta padro Operadores de consulta encadeada Sintaxe de query A palavra-chave let Continuao das queries Geradores mltiplos Juno

viii | Guia de Bolso: C# 3.0

Ordenao Agrupamento OfType e Cast Classes dos atributos Parmetros nomeados e posicionais Objetivos do atributo Especificao de atributos mltiplos Criao de atributos personalizados Recuperao de atributos em tempo de execuo Conceitos bsicos do ponteiro Cdigo unsafe A instruo fixed Operador Pointer-to-Member Arrays void* Ponteiros para cdigo no-gerenciado Atributos de condio Pragma warning Tags padres de documentao XML O Framework central Tecnologias de interface de usurio Tecnologias de backend Tecnologias de sistemas distribudos

164 165 167 168 168 169 169 170 170 171 172 172 172 173 174 174 175 175 176 177 177 178 179 181 182 187 190 192 195

Atributos

Cdigos unsafe e ponteiros

Diretivas pr-processadoras

Documentao XML Viso geral do Framework

ndice Remissivo

Sumrio | ix

C# 3.0 Guia de bolso

C# uma linguagem de programao orientada a objetos de uso geral e com segurana de tipos, cujo objetivo a produtividade do programador. Para este fim, a linguagem equaciona simplicidade, expressividade e desempenho. A linguagem C# indiferente plataforma, porm ela foi criada para funcionar melhor com o Microsoft .NET Framework. O C# 3.0 se destina ao .NET Framework 3.5.

O que h de novo no C# 3.0


Os recursos do C# 3.0 baseiam-se nas capacidades do LINQ (Language Integrated Query). O LINQ habilita as queries para serem escritas diretamente dentro de um programa em C#, semelhana do SQL, e verificadas estaticamente para correo. Queries podem executar tanto localmente quanto remotamente; o .NET Framework oferece APIs habilitadas para o LINQ em todas as colees locais, bancos de dados remotos e XML. Os recursos do C# 3.0 incluem: Expresses Lambda Mtodos de extenso Variveis locais declaradas implicitamente Queries de compreenso Tipos annimos Arrays declarados implicitamente Inicializadores de objetos Propriedades automticas Mtodos parciais rvores de expresso

Expresses Lambda so como funes em miniatura criadas dinamicamente. Elas so uma evoluo natural dos mtodos annimos introduzidos no C# 2.0 e, de fato, completamente subordinadas funcionalidade dos mtodos annimos. Por exemplo:
Func<int,int> sqr = x => x * x; Console.WriteLine (sqr(3)); // 9

O principal caso de uso no C# ocorre com as queries do LINQ, conforme a seguir:


string[] names = { Tom, Dick, Harry }; // Incluir apenas nomes com >= 4 caracteres: IEnumerable<string> filteredNames = Enumerable.Where (names, n => n.Length >= 4);

Mtodos de extenso estendem um tipo existente atravs de novos mtodos, sem alterar a definio do tipo. Eles agem comouma cobertura sinttica1, fazendo com que os mtodos estticos se paream com os mtodos de instncia. Como os operadores de query do LINQ so implementados como mtodos de extenso, podemos simplificar a nossa query anterior dessa forma:
IEnumerable<string> filteredNames = names.Where (n => n.Length >= 4);

Variveis locais tipificadas implicitamente aceitam omitir o tipo de varivel em uma instruo de declarao, permitindo que o compilador o deduza. Como o compliador pode determinar o tipo de filteredNames, podemos simplificar nossa query mais detalhadamente:
var filteredNames = names.Where (n => n.Length >= 4);

Sintaxe de compreenso de queries fornece sintaxe ao estilo SQL para a criao de queries. A sintaxe de compreenso pode simplificar certos tipos de queries de forma substancial, bem como servir de cobertura sinttica para queries ao estilo Lambda. Eis o exemplo anterior na sintaxe de compreenso:
var filteredNames = from n in names where n.Length >= 4 select n;

Tipos annimos so classes simples criadas dinamicamente, e geralmente so usadas no resultado final das queries:
var query = from n in names where n.Length >= 4 select new { Name = n, Length = n.Length };

Eis um exemplo mais simples:


var dude = new { Name = Bob, Age = 20 };

Arrays declarados implicitamente eliminam a necessidade de declarar o tipo de array ao construir e inicializar um array em apenas uma etapa:
var dudes = new[] { new { Name = Bob, Age = 20 }, new { Name = Rob, Age = 30 } };

Inicializadores de objeto simplificam a construo de objetos permitindo que as propriedades sejam definidas em linha aps a chamada do construtor. Os inicializadores de objeto funcionam com os tipos annimos e nomeados. Por exemplo:
Bunny b1 = new Bunny { Name = Bo, LikesCarrots = true, };

O equivalente em C# 2.0 :
Bunny b2 = new Bunny( ); b2.Name = Bo; b2.LikesCarrots = false;

Expresses automticas reduzem o trabalho de criar propriedades que simplesmente obtm/definem um campo de suporte privado. No exemplo a seguir, o compilador gera automaticamente um campo de suporte privado para X:
public class Stock { public decimal X { get; set; } }

Mtodos parciais permitem que uma classe parcial auto-gerada fornea ganchos personalizveis para autoria manual. LINQ para SQL usa mtodos parciais de classes geradas que mapeiam tabelas SQL. rvores de expresso so cdigos em miniatura de DOMs que descrevem expresses lambda. O compilador do C# 3.0 gera rvores de expresso quando uma expresso lambda atribuda ao tipo especial Expression<TDelegate>:
Expression<Func<string,bool>> predicate = s => s.Length > 10;

As rvores de expresso possibilitam s queries LINQ executarem remotamente (ex.: em um servidor de banco de dados), porque elas podem ser observadas e interpretadas em tempo de execuo (ex.: dentro de uma instruo SQL).

O primeiro programa em C#
Eis um programa que multiplica 12x30 e imprime o resultado, 360, para a tela. A barra dupla indica que o resto da linha um comentrio.
using System; class Test { static void Main( ) { int x = 12 * 30; Console.WriteLine (x); } } // importando namespace // declarao de classe // declarao de mtodo // instruo 1 // instruo 2 // fim do mtodo // fim da classe

No ncleo deste programa residem duas instrues. As instrues em C# executam seqencialmente. Cada instruo finalizada com um ponto-e-vrgula:
int x = 12 * 30; Console.WriteLine (x);

A primeira instruo calcula a expresso 12 * 30 e armazena o resultado em uma varivel local, chamada x, que um tipo de inteiro. A segunda instruo chama o mtodo WriteLine da classe Console para imprimir a varivel x em uma janela de texto na tela.

Um mtodo desempenha uma ao em uma seqncia de instrues chamada bloco de instrues um par de chaves que contm zero ou mais instrues. Definimos um mtodo simples chamado Main:
static void Main( ) { ... }

Criar funes de alto nvel que requisitam funes de nvel inferior simplifica um programa. Podemos transformar nosso programa com um mtodo reutilizvel que multiplica um inteiro por 12, conforme abaixo:
using System; class Test { static void Main( ) { Console.WriteLine (FeetToInches (30)); Console.WriteLine (FeetToInches (100)); } static int FeetToInches (int feet) { int inches = feet * 12; return inches; } }

// 360 // 1200

Um mtodo pode receber dados de entrada da chamada (caller) que especifica os parmetros, e pode retornar dados de sada para a chamada especificando um tipo de retorno. Definimos um mtodo chamado FeetToInches que possui um parmetro de entrada de dados em ps e um tipo de retorno de sada em polegadas:
static int InchesToFeet (int feet) {...}

Os literais 30 e 100 so os argumentos (parmetros) passados para o mtodo FeetToInches. O mtodo Main em nosso exemplo possui os parnteses vazios, porque no h parmetros, e ele void porque no retorna nenhum valor a quem chama:
static void Main()

C# reconhece um mtodo chamado Main como sinalizao do ponto de entrada padro de execuo. O mtodo Main pode retornar opcionalmente um inteiro (em vez de void) para retornar um valor ao ambiente de execuo. O mtodo Main tambm pode opcionalmente aceitar um array de argumentos de string (que ser preenchido com qualquer argumento passado para o executvel). Por exemplo:
static int Main (string[] args) {...}

Nota Um array (como string[]) representa um nmero fixo de elementos de um determinado tipo (consulte a prxima seo Arrays). Mtodos so um dos diversos tipos de funes em C#. Um outro tipo de funo que usamos foi o operador *, usado para executar uma multiplicao. Existem tambm os construtores, as propriedades, os eventos, os indexadores e os finalizadores. Em nosso exemplo, os dois mtodos so agrupados em uma classe. Uma classe agrupa membros de funo e membros de dados para formar um elemento orientado a objetos. A classe Console agrupa membros que manipulam a funcionalidade da linha de comando input/output, como o mtodo WriteLine. A nossa classe Test agrupa dois mtodos o mtodo Main e o mtodo FeetToInches. Uma classe uma espcie de tipo, que examinaremos mais adiante na seo Conceitos bsicos de tipos. No nvel externo mais extremo de um programa, os tipos so organizados em namespaces. A diretiva using disponibiliza o namespace System para outros aplicativos, portanto poderamos tomar como referncia System.Console sem o prefixo System. Poderamos definir todas as nossas classes dentro do namespace TestPrograms, conforme abaixo:
using System; namespace TestPrograms { class Test {...} class Test2 {...} }

O .NET Framework organizado em namespaces aninhados. Por exemplo, esse o namespace que contm tipos para manipulao de texto:
using System.Text;

A diretiva using encontra-se a para facilitar; voc tambm pode se referir a um tipo por meio de seu nome inteiramente qualificado, que o nome do tipo como prefixo de seu namespace, como em System. Text.StringBuilder.

Compilao
O compilador do C# compila o cdigo fonte, especificado como um conjunto de arquivos com extenso .cs, em um assembly. Um assembly a unidade de empacotamento e distribuio no .NET, e ele pode ser um aplicativo ou uma biblioteca. Um console normal ou aplicativo Windows possui um mtodo Main e um .exe. Uma biblioteca uma .dll e equivalente a um .exe sem um ponto de entrada. Seu objetivo ser requisitada (referenciada) por um aplicativo ou por outras bibliotecas. O .NET Framework um conjunto de bibliotecas. O nome do compilador do C# csc.exe. Voc tambm pode usar um IDE como o Visual Studio .NET para chamar csc automaticamente, ou compilar manualmente a partir da linha de comando. Para compilar manualmente, salve primeiro o programa em um arquivo como MyFirstProgram. cs e, em seguida, invoque csc (localizado em <windows>/Microsoft.NET/ Framework) a partir da linha de comando, conforme abaixo:
csc MyFirstProgram.cs

Isso gera um aplicativo chamado MyFirstProgram.exe. Para gerar uma biblioteca (.dll), voc digitaria:
csc /target:library MyFirstProgram.cs

Sintaxe
A sintaxe em C# baseia-se na sintaxe do C e C++. Nesta seo, descrevemos os elementos de sintaxe de C# usando o seguinte programa:
using System; class Test { static void Main( ) { int x = 12 * 30; Console.WriteLine (x); } }

Identificadores e palavras-chaves
Identificadores so nomes que os programadores escolhem para suas classes, mtodos, variveis e assim por diante. Eis os identificadores do nosso programa de exemplo na ordem em que aparecem:
System Test Main x Console WriteLine

Um identificador tem que ser uma palavra completa, composta essencialmente de caracteres Unicode que comeam com uma letra ou sublinhado. Os identificadores em C# tm maisculas e minsculas distinguidas pelo sistema. Por conveno, os argumentos, as variveis locais e os campos privados devem ser em camel case (ex.: myVariable), e todos os outros identificadores devem ser em Pascal case (ex.: MyMethod). Palavras-chaves so nomes reservados pelo compilador que no podem ser usados como identificadores. Eis as palavras-chaves do nosso programa de exemplo:
using class static void int

Abaixo, a lista completa das palavras-chaves de C#:


abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void while

Evitando conflitos
Se voc realmente deseja usar um identificador que conflita com uma palavra-chave, voc pode qualific-la com um prefixo @. Por exemplo:
class class {...} // ilegal class @class {...} // legal

O smbolo @ no faz parte do identificador, portanto @myVariable o mesmo que myVariable.

Palavras-chaves contextuais
Algumas palavras-chaves so contextuais, o que significa que elas tambm podem ser usadas como identificadores sem o smbolo @. A seguir, as palavras-chaves contextuais:
add ascending by descending equals from get global group in into join let on orderby partial remove select set value var where yield

Com palavras-chaves contextuais no surge ambigidade dentro do contexto em que elas so usadas.

Literais, marcadores de pontuao e operadores


Literais so fragmentos de dados primitivos incorporados estaticamente ao programa. Os literais do nosso programa de exemplo so 12 e 30. Marcadores de pontuao ajudam a demarcar a estrutura do programa. Eis os marcadores de pontuao do nosso programa de exemplo:
; { }

O ponto-e-vrgula usado para finalizar uma instruo, e ele permite que as instrues sejam quebradas em vrias linhas:
Console.WriteLine (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10);

As chaves so usadas para agrupar vrias instrues dentro de um bloco de instruo.

Operadores transformam e associam expresses. A maioria dos operadores em C# indicada por um smbolo, como o operador de multiplicao *. Discutiremos detalhadamente os operadores mais adiante neste livro. Eis os operadores que usamos em nosso programa de exemplo:
. () * =

O ponto se refere a um membro de alguma coisa. Os parnteses so usados ao se declarar ou chamar um mtodo; parnteses vazios so usados quando o mtodo no aceita argumentos. O sinal de igual usado para atribuio (o sinal duplo de igual, = =, usado para comparao de igualdade).

Comentrios
O C# oferece dois tipos diferentes de estilo de documentao de cdigo fonte: comentrios de uma nica linha e comentrios de vrias linhas. Um comentrio de uma nica linha comea com uma barra dupla e continua at o fim da linha. Por exemplo:
int x = 3; // comentrio sobre atribuir 3 a x

Um comentrio de vrias linhas comea com /* e termina com */:


int x = 3; /* este um comentrio que ultrapassa duas linhas */

Comentrios podem incorporar tags de documentao XML (consulte a prxima seo Documentao XML).

Conceitos bsicos de tipos


Um tipo define o esquema de um valor. Um valor um local de armazenamento indicado por uma varivel ou constante. Uma varivel representa um valor que pode mudar, enquanto que uma constante representa uma invariante. Criamos uma varivel local chamada x em nosso primeiro programa:
static void Main( ) { int x = 12 * 30; Console.WriteLine (x); }

Todos os valores em C# so instncias de um tipo especfico. O significado de um valor, e o conjunto de valores possveis que uma varivel pode ter, determinado por seu tipo. O tipo de x int.

Exemplos de tipos predefinidos


Os tipos predefinidos so tipos especialmente suportados pelo compilador. O tipo int um tipo primitivo predefinido de representao do conjunto de inteiros que cabe em 32 bits de memria, de - 231 a 231-1. Podemos executar funes, tais como as aritmticas, com instncias de tipo int, a saber:
int x = 12 * 30;

Um outro tipo de C# predefinido o tipo string. O tipo string representa uma seqncia de caracteres, tais como .NET ou http:// oreilly.com. Podemos manipular as strings invocando as funes, conforme abaixo:
string message = Ol mundo; string upperMessage = message.ToUpper( ); Console.WriteLine (upperMessage); // OL MUNDO int x = 2007; message = message + x.ToString( ); Console.WriteLine (message);

// Ol mundo2007

O tipo primitivo bool possui exatamente dois valores provveis: true e false. O tipo bool geralmente usado para acessar o fluxo de execuo estabelecido por uma instruo if. Por exemplo:
bool simpleVar = false; if (simpleVar) Console.WriteLine (Isso no imprimir); int x = 5000; bool lessThanAMile = x < 5280; if (lessThanAMile) Console.WriteLine (Isso imprimir);

Nota Em C#, os tipos predefinidos (tambm chamado de tipos embutidos) so reconhecidos por uma palavra-chave em C#. O namespace System no .NET Framework contm muitos tipos importantes que C# no predefine (ex.: DateTime). Exemplos de tipos personalizados Assim como podemos criar funes complexas a partir de funes simples, podemos criar tipos complexos a partir de tipos primitivos. Neste exemplo, definiremos um tipo personalizado chamado UnitConverter uma classe que serve como um esquema para converses de unidade: