Curso de C#

Quem sou eu - Original• Formado em processamento de dados pela UNIFIEO

• Coordenador da equipe de desenvolvimento da MSPi do Brasil Softwares de Gestão S/A

• Microsoft Certified Professional em ASP.NET

• Co-líder da célula acadêmica TouchAndTouch.NET

• Palestrante Microsoft .NET

Quem sou eu – Heitor• Aluno da cadeira de Jogos

– Mestrado Eng. De Software– Fábrica de software de jogos para dispositivos móveis

• Trabalho com dispositivos móveis (2002)– PALM, Celular ...

• Trabalho com jogos (2003)– Brew– J2ME

• Trabalhei com C# + Asp.Net em 2004– Apenas 3 meses :P– Aprendido “na tora[lmente]”

• Ajudante de introdução do curso de XNA– A idéia é não começar o curso zerado– Gerar debate e dúvidas

Agenda• Visão geral de C#• Utilizando variáveis do tipo valor• Comandos e exceções• Métodos e parâmetros• Matrizes (vetores)• Fundamentos da programação orientada a objetos• Utilizando variáveis do tipo referência• Criando e destruindo objetos• Herança em C#• Agregação, namespace e escopo avançado• Operadores, delegações e eventos• Propriedades e indexeradores• Atributos

Visão geral de C#

Objetivos

• Entender a estrutura básica de um programa simples escrito em C#

• Utilizar a classe Console para operações básicas de entrada / saída

• Gerar a documentação em XML de um programa escrito em C#

• Compilar e executar um programa escrito em C#

• Depurar um programa escrito em C#

Principais Características

• Case sensitive: diferencia maiúsculas de minúsculas

• Fortemente tipada: todas as variáveis devem ser declaradas

• Orientada a objetos: tudo é um objeto no .NET Framework

• Geralmente as linhas são terminadas com “;”

• O método Main

Hello World

using System;class Hello{

public static void Main( ){

Console.WriteLine(“Hello World”);}

}

Classe Console

• Console.Write:Console.Write( “TouchAndThink.NET” );

• Console.WriteLine:Console.WriteLine( “TouchAndThink.NET” );

• Console.Read:char letra = Console.Read( );

• Console.ReadLine:string linha = Console.ReadLine( );

Exercício

Vamos utilizar o Microsoft Visual Studio 2005 para desenvolver o programa Hello World

Tipos de Comentários

• Comentando uma única linha– //

• Comentário várias linhas– /* ... */

• Documentação XML– ///

Documentação XML

using System;

/// <summary>/// Este é meu primeiro programa em C#/// </summary>class Hello{

/// <remarks>/// Utilizando o método WriteLine da classe Console/// <seealso cref="System.Console.WriteLine"/>/// </remarks>public static void Main( ){

Console.WriteLine( "Hello World Documentado" );}

}

Tags Documentação XML

• <summary>...</summary>Breve descrição

• <remarks>...</remarks>Descrição detalhada

• <seealso cref>...</ seealso>Indica uma referência para outro membro ou campo

• Documentação completa em:http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csref/html/vclrftagsfordocumentationcomments.asp

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csref/html/vclrftagsfordocumentationcomments.asp













Gerando Documentação XML

• Através do Visual Studio:->Menu Project

-> Properties -> Build

->XML Documentation File

• Através da janela de comando:csc meuprograma.cs /doc:meuxml.xml

Exercício

Gerando a documentação XML de um programa escrito em C#

Compilando

• Através do Microsoft Visual Studio:->Menu Build

-> Build Solution

• Através da janela de comando:csc /out:meuprograma.exe meuprograma.cs

Executando

• Através do Microsoft Visual Studio:-> Menu Debug

-> Start Without Debugging (CTRL+F5)

• Através da janela de comando:Digite o nome da aplicação (.EXE)

Depurando

• Configurando “breakpoints”Right Click na linha -> Insert BreakPointExecute um clique na margem esquerda

• Executando passo-a-passo->Menu Build

->Start (F5)

• Examinando e modificando variáveisAtravés da janelas Autos e Wacth

Exercício

Compilar, executar e depurar um programa escrito em C#

Ferramentas SDK

• CORDBG.EXE (Runtime Debugger)Depurador de linha de comando

• ILASM.EXE (MSIL Assembler)Pega a MSIL e gera o executável

• ILDASM.EXE (MSIL Disassembler)Gera MSIL a partir de código executável

• Lista completa de utilitários em:http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cptools/html/cpconNETFrameworkTools.asp

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cptools/html/cpconNETFrameworkTools.asp

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cptools/html/cpconNETFrameworkTools.asp

Demonstração

Utilizando o utilitário de linha de comando ILDASM para verificar código MSIL

Utilizando variáveis do tipo valor

Objetivos

• Entender os tipos de dados do C#• Nomear variáveis• Declarar variáveis• Atribuir valor à variáveis• Criar seus próprios tipos de dados• Conversão entre tipos de dados

Commom Type System

• Parte do CLR (Commom Language RunTime)

• Compartilhado entre todas as linguagens .NET

• Tipos de variáveis:– Value types– Reference types

Value Types

• Existem dois tipos de value types

– Built-in types (Simple types)intfloat

– User defined typesenumstruct

Simple Types

• Identificados através de palavras reservadas

• Essas palavras reservadas são na verdade “apelidos” para estruturas pré-definidas

• Exemplo:– int // palavra reservada– System.Int32 // struct type

Simple TypesPalavra reservada Estrutura Valores Permitidos

sbyte System.SByte Inteiros entre -128 e 127

byte System.Byte Inteiros entre 0 e 255

short System.Int16 Inteiros entre -32768 e 32767

ushort System.UInt16 Inteiros entre 0 e 65535

int System.Int32 Inteiros entre -2137483648 e 2147483647

uint System.UInt32 Inteiros entre 0 e 4294967295

long System.Int64 Inteiros entre -9223372036854775808 e 9223372036854775807

ulong System.UInt64 Inteiros entre 0 e 18446744073709551615

float System.Single 1,5x10^-45 até 3,4x10^38

double System.Double 5,0x10^-324 até 1,7x10^308

decimal System.Decimal 1,0x10^-28 até 7,9x10^28

bool System.Boolean Valor booleano, verdadeiro ou falso

char System.Char Caracteres single unicode

string System.String Sequência de caracteres

Nomeando variáveis

• Regras:– Iniciar com caracter ou underscore– Depois do primeiro caracter, utilize caracteres e/ou

dígitos– Não utilizar palavras reservadas

• Recomendações:– Evitar utilizar todas as letras maiúsculas– Evitar iniciar com underscore– Evitar utilizar abreviações– Utilizar “PascalCasing” para variáveis de múltiplos

nomes• classes, métodos, propriedades, enums, interfaces, campos

de somente leitura, constantes, namespaces e propriedades– CamelCasing

• campos e parâmetros

Palavras reservadas em 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 stacklloc static string

struct switch this throw true

try typeof uint ulong unchecked

unsafe ushort using virtual void

volatile while

Declarando Variáveis Locais

• Identificar o tipo e o nome da variável:

int num1;

• Você pode declarar múltiplas variáveis em uma mesma linha:

int num1, num2, num3;

Atribuindo Valores à Variáveis

• Atribua valores à variáveis através do operador “=“

int num1; // Declarando a variávelnum1 = 0; // Atribuindo valor

OU

int num1 = 0; // Declarando a variável e já inicializando a mesma

“Shortland”

• Ao invés de escrever:int num1 = 0;num1 = num1 + 4;

• Escreva:int num1 = 0;num1 += 4;

• Isso funciona com todos os operadores aritméticos

Operadores

Operador ExemploComparação == !=

Relacionais < > <= >= is

Condicionais && || ?:

Incremento ++

Decremento --

Aritimético + - * / %

Atribuição = *= /= %= += -=

Incremento e Decremento

• Ao invés de escrever:int num1 = 0;num1 = num1 + 1;

• Escreva:int num1 = 0;num1++;

• Isso funciona com todos os operadores “+” e “-”

Incremento e Decremento

• Existem duas formas:

num1++;++num1;

• Exemplos:

int numero = 10;int preresultado = ++numero; // preresulatdo =11int posresultado = numero++; // preresulatdo =11

Precedência

• As expressões são resolvidos da esquerda para direita (com exceção dos operações de igualdade)

x + y + z é resolvido como ( x + y ) + z

• Os operadores de igualdade são resolvidos da direita para a esquerda

x = y = z é resolvido como x = ( y = z )

Precedência

• Os operadores atitméticos *, / e % tem maior precedência do que os operadores + e –

x + y * z é resolvido como x + ( y * z )

• Você pode altetar a precedência através do uso de parênteses

( x + y ) * z

Exercício

Desenvolva um programa em C# que declara variáveis do tipo simples, atribua valores a estas variáveis e mostre seus respectivos

valores na tela

Enumerações

• Definida através da palavra chave enum:

enum Cor { Branca, Preta, Azul }

• Utilizando uma enumeração:Cor corParede = Cor.Branca;

• Mostrando valor de uma enumeração:// Mostra BrancaConsole.WriteLine( corParede );

Estruturas

• Definida através da palavra chave struct:

public struct Pessoa{

public string nome;public int idade;

}

• Utilizando uma estrutura:

Pessoa pes; // Declara a variávelpes.nome = “João”; // Altera o valorpes.idade = 25;

Exercício

Desenvolver um programa em C# que faça uso de enumerações e estruturas

Convertendo Variáveis

• C# suporta dois tipos de conversão:

– Conversão implícita de dados

– Conversão explícita dedados

Conversão Implícita

• O C# se encarrega de efetuar a conversão:

int intValue = 123;long longValue = intValue;

• Conversões implícitas não falham: podem perder precisão, mas não magnitude

Conversão Explícita

• Para conversões explicitas, você deve utilizar uma expressão cast:

long longValue = Int64.MaxValue;int intValue = (int)longValue;

• Conversões explícitas podem falhar. Você pode tratar esse tipo de erro através do uso do bloco checked

checked / unchecked

// Será gerada uma exceção no caso de “overflow”checked{

long longValue = Int64.MaxValue;int intValue = (int)longValue;Console.WriteLine( intValue );

}

// Não será gerada uma exceção no caso de “overflow” unchecked

{long longValue = Int64.MaxValue;int intValue = (int)longValue;Console.WriteLine( intValue );

}

Exercício

Desenvolver um programa em C# que faça conversão implícitas e explícitas de variáveis

Comandos e exceções

Objetivos

• Utilizar bloco de comandos• Utilizar comandos de seleção• Utilizar comandos de repetição• Tratamento de exceções

Bloco de comandos

• Delimitado por { }• Você pode “aninhar” blocos• Exemplo:{

{int numero;numero = 5;

}}

Exemplo 1

{int numero;numero = 5;Console.WriteLine( "{0}", numero );

}Console.WriteLine( "{0}", numero );{

int numero;numero = 10;Console.WriteLine( "{0}", numero );

}

Exemplo 2

{int numero;{

int numero;numero = 5;Console.WriteLine( "{0}", numero );

}}

Tipos de comandos

• Seleçãoif e switch

• Repetiçãowhile, do, for e foreach

• Quebra e continuidadebreak e continue

if

Sintaxe:

if (expressão booleana)bloco de comandos do if

elsebloco de comandos do else

if – exemplo 1

int numero = int.Parse( Console.ReadLine( ) );

if ( numero % 2 == 0 )Console.WriteLine( "PAR" );

elseConsole.WriteLine( "ÍMPAR" );

if – exemplo 2

int posicao = int.Parse( Console.ReadLine( ) );

if ( posicao == 1 )Console.WriteLine( "OURO" );

else if ( posicao == 2 )Console.WriteLine( "PRATA" );

else if ( posicao == 3 )Console.WriteLine( "BRONZE" );

elseConsole.WriteLine( "Treinar mais" );

if – exemplo 3


if ( numero < 10 )numero++;Console.WriteLine( numero );Console.WriteLine( "Menor que dez" );

if – exemplo 4


if ( numero < 10 ){

numero++;Console.WriteLine( numero );Console.WriteLine( "Menor que dez" );

}

Exercício

Escolha um dos exemplos apresentados do comando if e coloque-o em prática

switch

Sintaxe:

switch ( variável ) // integer, char, enum ou string{

case constante1:bloco de comandos



default:bloco de comandos

}

switch – exemplo 1

int mes = int.Parse( Console.ReadLine( ) );int dias;switch ( mes ){

case 2:dias = 28;break;

case 4:case 6:case 9:case 11:

dias = 30;break;

default:dias = 31;break;

}Console.WriteLine( dias );

Exercício

Desenvolva um pequeno menu e trata a opção digitada pelo usuário fazendo uso do comando

switch

while

Sintaxe:

while ( expressão booleana ){

bloco de comandos}

while – exemplo 1

int contador = 0;while (contador < 10 ){

contador++;Console.WriteLine( "{0}", contador );

}

while – exemplo 2

int contador = 10;while (contador < 10 ){


}

do while

Sintaxe:

do {

bloco de comandos}while ( expressão booleana );

do while – exemplo 1

int contador = 0;do{


}while ( contador < 10 );

do while – exemplo 2

int contador = 10;do{


}while ( contador < 10 );

for

Sintaxe:

for ( inicialização ; condição ; incremento ){

bloco de comandos}

for – exemplo 1

for ( int i = 1 ; i <= 10 ; i++ ){

Console.WriteLine( "{0}", i );}

for – exemplo 2

for ( int i = 1 ; i <= 10 ; i++ ){

Console.WriteLine( "{0}", i );}Console.WriteLine( "{0}", i );

for – exemplo 3

for ( int i = 1, k = 1 ; i <= 10 ; i++, k++ ){

Console.WriteLine( "{0}", i );Console.WriteLine( "{0}", k );

}

Exercício

Desenvolva um programa em C# que solicite um número ao usuário e imprima a tabuada desse

número

foreach

Sintaxe:

foreach ( variável in coleção ){

bloco de comandos}

foreach – exemplo 1

ArrayList numeros = new ArrayList( );for( int contador = 1 ; contador <= 10 ; contador++ ){

numeros.Add( contador );}

foreach ( int numero in numeros ){

Console.WriteLine( "{0}", numero );}

continue / break

int i = 0;while ( true ){

i++;if ( i > 10 ) {

break;}else {

Console.WriteLine( i );continue;

}}

Exercícios

1 - Desenvolver um programa em C# que solicita um número ao usuário e verifica se este

número e positivo ou negativo

2 - Desenvolver um programa em C# que solicite dois números ao usuário (base e expoente) e

calcule o valor da potência

Exceptions

ExceptionSystemException

OutOfMemoryExceptionIOExceptionNullReferenceException

ApplicationException

try...catch...finally

try{}catch ( OverflowException oe ){}catch ( InvalidCastException ice ){}catch ( Exception e ){}finally{}

try...catch – exemplo - 1try{

int dividendo = int.Parse( Console.ReadLine( ) );int divisor = int.Parse( Console.ReadLine( ) );int resultado = dividendo / divisor;Console.WriteLine( resultado );

}catch ( Exception e ){

Console.WriteLine( "Ocorreu um erro:\n" + e.Message);}finally{

Console.WriteLine( “Fim" );}

throw

int minutos = int.Parse( Console.ReadLine( ) );if ( minutos < 1 || minutos >= 60 ){

throw new Exception( "horário inválido" );}

throw – exemplo 1

try{

int minutos = int.Parse( Console.ReadLine( ) );if ( minutos < 1 || minutos >= 60 ){

throw new Exception( "horário inválido" );}Console.WriteLine( minutos );

}catch ( Exception e ){

Console.WriteLine( e.Message );}

Exceptions

• Todas as exceções derivam (e devem derivar) de System.Exception

• Sempre utilizar uma exceção genérica (Exception)

• Ordem de tratamento: da exceção menos genérica para a mais genérica

Exercício

Desenvolver um programa em C# que solicite dois números ao usuário e mostre o resultado

dessa divisão na tela (faça uso do bloco try...catch para tratamento de erros)

Métodos e parâmetros

Objetivos

• Definir e utilizar métodos estáticos• Passar parâmetros para métodos• Definir e utilizar sobrecarga de métodos

MétodosSintaxe:

Modificador(es) Retorno Nome (Lista de parâmetros){

Corpo do método}

Especificar:– Modificador(es) (opcional)– Retorno– Nome (identificador válido)– Lista de parâmetros– Corpo do método

MétodosExemplo 1

using System;

class Exemplo{

static void DizerAlo( ){

Console.WriteLine( "Alo" );}public static void Main( ){

DizerAlo( );}

}

Chamando Métodos

• Dentro da mesma classe:Apenas especifique o nome do método

• De outra classe:Especifique o nome da classe e o nome do método

MétodosExemplo 2

using System;

class Exemplo{

static void DizerAlo( ){

Console.WriteLine( "Alo" );}public static void Main( ){

Console.WriteLine( "Início");DizerAlo( );

Console.WriteLine( "Fim" );}

}

using System;

class Um{

public static void DizerAlo( ){

Console.WriteLine( "Alo" );}

}

class Dois{


Um.DizerAlo( );}

}

MétodosExemplo 3

using System;class Exemplo{

static void Metodo1( ){

Console.WriteLine( "UM" );}static void Metodo2( ){

Metodo1( );Console.WriteLine( "DOIS" );Metodo1( );

}public static void Main( ){

Metodo2( );Metodo1( );

}}

Exercício

Desenvolva um programa em C# que possua um método que escreva o seu nome na tela

return

using System;

class Exemplo{

static void Main( ){

Console.WriteLine( "Hello" );return;Console.WriteLine( "World" );

}}

Variáveis Locais

• Variáveis declaradas dentro de métodos são chamadas variáveis locais

• São visíveis apenas para o método onde foram definidas

• São criadas no início da execução do método e destruídas no final da execução deste

VariáveisExemplo 1

using System;

class Exemplo{

static void Contar( ){

numero++;}public static void Main( ){

int numero = 0;Contar( );Console.WriteLine( numero );

}}

VariáveisExemplo 2

using System;

class Exemplo{

static int numero = 0;static void Contar( ){


Contar( );Console.WriteLine( numero );

}}

VariáveisExemplo 3

using System;

class Exemplo{

static int numero = 0;static void Contar( ){


int numero = 0;Contar( );Console.WriteLine( numero );

}}

Retornando valores

• Declarar o método sem o tipo void

• Especificar o tipo de dado de retorno do método no lugar da palavra void

• Especificar o valor de retorno no comando return

• Um método não void sempre deve retornar um valor

Retornando valores Exemplo

using System;

class Exemplo{

static int GetNumero( ){

Console.Write( "Digite um número: " );int numero = int.Parse( Console.ReadLine( ) );return ( numero );


int numero = GetNumero( );Console.WriteLine( numero );

}}

Exercício

Desenvolver um programa em C# que possui um método que retorna a data de hoje e imprima

essa data na tela

Parâmetros

• Variáveis que são passadas para os métodos

• Informar os parâmetros entre parênteses após o nome dos métodos

• Defina o tipo de dado e o nome de cada parâmetro (se existir mais de um parâmetro, separá-los utilizando vírgulas)

• Informar os parâmetros na chamado do método

ParâmetrosExemplo

using System;

class Exemplo{

static void DizerOla( string nome ){

Console.WriteLine( "Ola " + nome );}


string nome = "João";DizerOla( nome );

}}

Exercício

Desenvolver um programa em C# que possui um método que efetua a operação matemática de

soma.

Solicite dois números ao usuário e utilize esse método para somar esses números e mostrar

o resultado na tela

Passagem de Parâmetros

in Passagem por valor

in

out Passagem por referência

out Parâmetros de saída (output)

Passagem por valor

• Mecanismo padrão de passagem de parâmetro

• Parâmetro pode ser alterado no corpo do método e não terá efeito no valor do variável utilizada na chamada do método

Passagem por valor Exemplo


static void SomarUm( int numero ){


int num = 1;SomarUm( num );Console.WriteLine( num );

}}

Passagem por referência• É uma referência para uma mesma região na memória

• Utilizar a palavra chave ref na definição e na chamada do método

• Alterações no parâmetro irá afetar a variável utilizada na chamada do método

• Utilizar a palavra chave ref para cada um dos parâmetros do método que são referência(s)

• Sempre inicialize a variável antes de utilizá-la como parâmetro de referência

Passagem por referência Exemplo


static void SomarUm( ref int numero ){


int num = 1;SomarUm( ref num );Console.WriteLine( num );

}}

Parâmetros de saída

• Também é uma referência para a mesma região na memória

• Utilizar a palavra chave out na definição e na chamada do método

• Utilizar a palavra chave out para cada um dos parâmetros do método que são de saída

• Você não precisa inicializar a variável antes de utilizá-la como parâmetro de saída

Parâmetro de saídaExemplo


static void GetNomeIdade( out string nome, out int idade ){

Console.Write( "Digite seu nome: " );nome = Console.ReadLine( );Console.Write( "Digite sua idade: " );idade = int.Parse( Console.ReadLine( ) );


string nome;int idade;GetNomeIdade( out nome, out idade );Console.WriteLine( "Nome: " + nome + "\nIdade: " + idade.ToString( ) );

}}

Exercício

Colocar em prática os exercícios vistos até aqui para visualizar as diferenças entre os

mecanismos de passagem de parâmetros

Lista de parâmetros variada

• Utilizar quando não se sabe ao certo o número de parâmetros que o método irá receber

• Utilizar a palavra chave params

• Deve ser sempre o último parâmetro da lista de parâmetros

• Mecanismo utilizado é sempre passagem por valor

Lista de parâmetros variada Exemplo

using System;

class Exemplo{

static void Nomes( params string[ ] nomes ){

foreach( string nome in nomes ){

Console.WriteLine( nome );}


Nomes( "João", “Tiago", "Leonardo", "Rodolfo" );}

}

Sobrecarga de métodos

• Métodos com mesmo nome em uma classe, porém com assinaturas diferentes

• Os métodos devem possuir listas de parâmetros diferentes

• Você não pode compartilhar nomes entre variáveis, enumerações, estruturas, etc... Apenas entre métodos

Assinatura de métodos

• Definição:– Nome do método– Tipo de dado dos parâmetros– Modificador do(s) parâmetro(s) (ref e out)

• Não tem efeito:– Nome(s) do(s) parâmetro(s)– Tipo de dado de retorno do método

Sobrecarga de métodos Exemplo

using System;

class Exemplo{

static int Soma( int num1, int num2 ){

return ( num1 + num2 );}static int Soma( int num1, int num2, int num3 ){

return ( num1 + num2 + num3 );}public static void Main( ){

Console.WriteLine( Soma( 1, 2 ) );Console.WriteLine( Soma( 1, 2, 3 ) );

}}

Exercício

Desenvolver um programa em C# que faça uso de sobrecarga de métodos

Matrizes (vetores)

Objetivos

• Visão geral de matrizes• Criando matrizes• Utilizando matrizes• Coleções

Matrizes

• Utilizada para agrupamento de dados

• É uma seqüência de elementos

• Todos os elementos devem ser do mesmo tipo de dado

• Elementos são acessados utilizando-se um (ou mais) índice(s) inteiro(s)

MatrizesExemplo 1

using System;

class Matrizes{


int num1 = 1;int num2 = 2;int num3 = 3;int num4 = 4;int num5 = 5;Console.WriteLine( num1 );Console.WriteLine( num2 );Console.WriteLine( num3 );Console.WriteLine( num4 );Console.WriteLine( num5 );

}}

using System;

class Matrizes{ static void Main( ) {

int[ ] numeros = new int[5] {1, 2, 3, 4, 5}; for ( int i = 0 ; i < 5 ; i++ ) { Console.WriteLine(numeros[i]); }

}}

Matrizes – Notação em C#

Sintaxe:

tipo_de_dado[ ] nome_da_matriz;

Especificar:– Tipo de dado dos elementos da matriz– Colchetes (sem o número de elementos)– O nome da variável da matriz

Declarando Matrizes

Matrizes de uma dimensão (unidimensionais)

int[ ] numeros;

Um índice associado a cada elemento da matriz

Matrizes de duas dimensões (bidimensionais)

int [ , ] numeros;

Dois índices associados a cada elemento da matriz

Cada vírgula utilizada entre os colchetes cria uma nova dimensão para a matriz

Acessando Elementos

• Informe o nome da matriz e índice desejado entre colchetes

int num = numeros[ 1 ];int num = numeros[ 1, 1 ];

• O elemento inicial da matriz é acessado através do índice 0

int num = numeros[ 0 ];int num = numeros[ 0, 0 ];

Alterando Elementos

• Informe o nome da matriz e índice desejado entre colchetes

numeros[ 1 ] = 10;

numeros[ 1, 1 ] = 10;

Criando Matrizes

• Apenas declarar a matriz não cria uma instância da mesma (as matrizes são tipos de dados referência e não tipos simples)

• Você deve utilizar a palavra chave new para criar uma instância da matriz

• Você deve especificar a dimensão da matriz no momento da criação (você não poderá redimensionar a matriz após sua criação)

• Os elementos da matriz são implicitamente inicializados

MatrizesExemplo 2

using System;

class Matrizes_2{


int[ ] numeros = new int[ 5 ];for ( int i = 0 ; i < 5 ; i++ ){

Console.WriteLine( numeros[ i ] );}

}}

Exercício

Desenvolver um programa em C# que declara e cria matrizes. Acesse e altere os elementos

dessas matrizes

Inicializando Matrizes

• Você pode inicializar os elementos da matriz no momento da criação com valores que desejar

• Você pode utilizar expressões complexas na inicialização de matrizes (variáveis, expressões, métodos, etc)

• Você sempre deve explicitamente inicializar todos os elementos da matriz (o número total de elementos da matriz)

MatrizesExemplo 3

using System;

class Matrizes_3{


int[ ] numeros = new int[ 5 ] { 1, 2, 3, 4, 5 };

for ( int i = 0 ; i < 5 ; i++ ){


}}

Inicializando Matrizes Multidimensionais

• Todas as regras para inicialização de matrizes unidimensionais devem ser seguidas na inicialização de matrizes multidimensionais

• Você deve inicializar todos os elementos de todas as dimensões da matriz multidimensional

MatrizesExemplo 4

using System;

class Matrizes_4{


int[ , ] numeros = { { 1, 2, 3 }, { 4, 5, 6 } };

for ( int i = 0 ; i < 2 ; i++ ){

for ( int k = 0 ; k < 3 ; k++ ){

Console.WriteLine( numeros[ i, k ] );}

}}

}

Exercício

Alterar o exercício anterior para inicializar as matrizes criadas

Dimensionando Matrizes em Tempo de Execução

• O número de elementos de uma matriz não precisa ser uma constante (pode ser definido em tempo de execução)

• Se definido em tempo de execução, não podemos inicializar explicitamente os elementos da matriz

MatrizesExemplo 5

using System;

class Matrizes_5{


Console.Write( "Número pessoas: " );int numPessoas = int.Parse( Console.ReadLine( ) );

string[] pessoas = new string[ numPessoas ];

for( int i = 0 ; i < numPessoas ; i ++ ){

Console.Write( "{0} pessoa: ", ( i + 1 ) );pessoas[ i ] = Console.ReadLine( );

}

for ( int i = 0 ; i < numPessoas ; i++ ){

Console.WriteLine( pessoas[ i ] );}

}}

Copiando Matrizes

• Quando você faz a cópia de uma matriz, na verdade as duas variáveis estão apontando para a mesma região na memória

• Isso se deve ao fato das matrizes serem tipos de dados referência e não tipos de dados simples

MatrizesExemplo 6

using System;

class Matrizes_6{


int[] numeros = { 1, 2, 3, 4, 5 };int[] copiaNumeros = numeros;

copiaNumeros[ 0 ]++;

Console.WriteLine( numeros[ 0 ] );Console.WriteLine( copiaNumeros[ 0 ] );

}}

Propriedades e Métodos das Matrizes

• As matrizes são implicitamente derivadas de System.Array. Esta classe fornece uma série de métodos e propriedades interessantes para manipulação de matrizes

• Os elementos das matrizes podem ser percorridos com o comando foreach

Propriedades

• Rank: contém a dimensão da matriz

• Length: contém o número de elementos da matriz

int[ ] numeros = new numeros[ 5 ]rank = 1lenght = 5

int[ , ] numeros = new numeros[ 2, 4 ]rank = 2lenght = 8

MatrizesExemplo 7

using System;

class Matrizes_7{


int[] numeros1 = { 1, 2, 3, 4, 5 };Console.WriteLine( "Rank..: {0}", numeros1.Rank );Console.WriteLine( "Length: {0}", numeros1.Length );

int[,] numeros2 = { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 } };Console.WriteLine( "Rank..: {0}", numeros2.Rank );Console.WriteLine( "Length: {0}", numeros2.Length );

}}

Métodos

• Sort: ordena os elementos da matriz de uma dimensão

• Clear: “reseta” elementos da matriz para as posições informadas

• Clone: cria uma cópia da matriz (nova instância)

• GetLength: retorna a dimensão da matriz. Possui comportamento diferente entre matrizes unidimensionais e multidimensionais

MatrizesExemplo 8

using System;

class Matrizes_8{


int[] numeros = new int[ 5 ] { 5, 3, 1, 2, 4 };System.Array.Sort( numeros );for( int i = 0 ; i < numeros.Length ; i++ ){


}}

Exercício

Desenvolver um programa que solicita um número ao usuário

O programa deverá solicitar ao usuário N números

Imprimir os N números digitados ordenados

Retornando Matrizes de Métodos

using System;

class Matrizes_9{


int[] numeros = GetNumeros( );for ( int i = 0 ; i < numeros.Length ; i ++ ){


}static int[] GetNumeros( ){

int[] numeros = new int[5] { 1, 2, 3, 4, 5 };return ( numeros );

}}

Passando Matrizes como Parâmetro para Métodos

using System;

class Matrizes_10{


int[] numeros = new int[ 5 ] { 1, 2, 3, 4, 5 };ImprimeNumeros( numeros );

}static void ImprimeNumeros( int[ ] numeros ){

for ( int i = 0 ; i < numeros.Length ; i ++ ){


}}

Argumentos de Linha de Comando

using System;

class Matrizes_11{

static void Main( string[] args ){

for ( int i = 0 ; i < args.Length ; i++ ){

Console.WriteLine( args[ i ] );}

}}

Percorrendo Matrizes com o comando foreach

using System;

class Matrizes_12{


int[] numeros = new int[ 5 ] { 1, 2, 3, 4, 5 };foreach ( int numero in numeros ){

Console.WriteLine( numero );}

}}

Exercício

Alterar o exercício anterior para percorrer a matriz utilizado o comando foreach

Considerações sobre Matrizes

• Você não pode redimensionar uma matriz após a sua criação

• Você só pode armazenar elementos de mesmo tipo em uma matriz

• Em geral, matrizes são rápidas, mas pouco flexíveis

• Para superar essas “carências”, podemos fazer uso de coleções

Coleções

using System;using System.Collections;

public class Colecao{


ArrayList lista = new ArrayList( );lista.Add( "TouchAndThink" );lista.Add( 99 );lista.Add( true );lista.Add( DateTime.Now );foreach( object elemento in lista ){

Console.WriteLine( elemento.ToString( ) );}

}}

Fundamentos da programação orientada

a objetos

Objetivos

• Classes e objetos• Abstração• Encapsulamento• Membros estáticos• Herança• Polimorfismo• Orientação a objetos em C#

Classe

• Uma “molde” que descreve comportamento e atributos padrões de uma determinada entidade

• Exemplo: todos os carros possuem comportamento e características que são padrões entre todos os carros (conjunto de todos os carros)

Classe

• Composta por membros:

– Campos (características, propriedades)NomeCorAno

– Métodos (operações)LigarAcelerarBrecar

Objeto

• Um objeto é uma instância (ocorrência) de uma classe

• Exemplo: uma ferrari seria um exemplo de uma instância da classe carro

Tipo Valor x Tipo Referência

• Tipo valor– Tipos de dados simples– int, decimal, char, bool, enum, struct– Armazenados na pilha (stack)

• Tipo referência– Objetos– SqlConnection, Console, nossas classes– Armazenados na memória dinâmica (heap)

Tipo Valor x Tipo Referência Exemplo

using System;using System.Collections;

class TipoSimplesReferencia{


int numero;numero = 0;

ArrayList lista = new ArrayList( );lista.Add( 0 );

}}

Abstração

Abstração consiste em focalizar os aspectos essenciais inerentes a uma

entidade e ignorar propriedades “acidentais”

Abstração pode ser definida como a capacidade de representar cenários complexos usando termos simples

Fonte: MSDN Magazine

Abstração

• Deve levar em consideração aspectos importantes da entidade e descartar aspectos desnecessários

• A classe deve fornecer comportamento essencial da entidade modelada e de maneira fácil e simples de ser utilizada

• A abstração, quando bem aplicada, faz coisas complexas parecerem simples

Encapsulamento

Encapsulamento pode ser definido como a tarefa de tornar um objeto

o mais auto-suficiente possível


Encapsulamento

• Combinar dados e métodos em uma “cápsula” (classe)

• Controlar o acesso a membros da “cápsula” (classe)

– Métodos são públicos, acessíveis do lado de fora da classe (palavra chave public)

– Atributos são privados, acessíveis somente pela classe (palavra chave private)

• Facilidade de uso: “esconder” a complexidade do comportamento da entidade na classe (chamada a métodos)

EncapsulamentoExemplo

using System;

class ContaBancaria{

private decimal saldo;

public void Deposito ( decimal valor ){this.saldo += valor;}

public bool Saque ( decimal valor ){bool sucesso = ( this.saldo >= valor );if ( sucesso ){this.saldo -= valor;}return ( sucesso );}

public decimal SaldoConta( ){return ( this.saldo );}

}

Campos do Objeto

• Campos que descrevem características de objetos individuais

• Exemplos: – cada carro possui um número de placa diferente– cada pessoa possui um número de cpf diferente– Cada conta bancária possuiu seu próprio saldo

• Você precisa criar uma instância da classe para fazer uso de campos de objetos

Campos Estáticos

• Campos que descrevem características de todos os objetos de uma classe

• Campos no nível da classe

• Exemplos:– todos os carros possuem quatro rodas– todas as contas bancarias possuem mesma taxa de

rendimento mensal

• Você não precisa criar uma instância da classe para fazer uso de campos estáticos

Métodos Estáticos

• Assim como os campos estáticos, os métodos estáticos estão no nível da classe

• Métodos estáticos só podem acessar atributos estáticos

• A chamada para um método estático é efetuada no nível da classe e não nível do objeto

• Você não precisa criar uma instância da classe para fazer uso de métodos estáticos

Membros EstáticosExemplo 1

using System;

class PessoaNaoEstatica{

public void Falar( string frase ){Console.WriteLine( frase );}

}

class TestePessoaNaoEstatica{

static void Main( ){PessoaNaoEstatica pes = new PessoaNaoEstatica( );pes.Falar( "TouchAndThink.NET" );}

}

Membros EstáticosExemplo 2

using System;

class PessoaEstatica{

public static void Falar( string frase ){

Console.WriteLine( frase );}

}class TestePessoaEstatica{


PessoaEstatica.Falar( "TouchAndThink.NET" );}

}

Exercício

Colocar os exemplos de membros estáticos e não estáticos em prática para perceber a

diferença entre eles

Definindo Classes

• Fazer uso da palavra chave class

• Definir campos e métodos da classe

• Sintaxe semelhante da definição de estruturas

• Boa prática: métodos públicos, campos privados (recomendação)

Definição de ClassesExemplo

using System;

class Pessoa{

private string nome;private int idade;private char sexo;

public void Falar( string frase ){


}

Exercício

Escrever uma classe em C# que abstrai e encapsula algumas características de um carro

Modificadores de Tipo de Acesso

• Public: acesso não limitado

• Private: acesso limitado ao escopo da classe.

Você pode combinar os modificadores de acessocom static

Se você não especificar um modificador de tipode acesso para um membro da classe, este serápor padrão private (campos e métodos)

Modificadores Exemplo

using System;

class Pessoa{

private string nome;private int idade;private char sexo;

public void Falar( string frase ){


}

Criando Objetos

• Apenas declarar uma variável de uma classe não cria um objeto desta classe

• Faça uso do operador new para criar um objeto de uma determinada classe

• Todos os campos da classe são inicializados quando criamos um objeto

• Criar um objeto muitas vezes é chamado de instanciar um objeto

Criando Objetos Exemplo

using System;

//Definição da classe

class TestePessoa{


Pessoa pes1 = new Pessoa( );pes1.Falar( "Oi" );

}}

Exercício

Escrever uma classe que crie objetos da classe carro criada no exercício anterior

Palavra chave this

• this se refere implicitamente ao objeto atual

• Pode ser resolvida para se resolver problemas de conflito de escopo

• Métodos estáticos não podem fazer uso da palavra chave this (pois método estáticos se encontram no nível da classe)

this Exemplo

class Carro{

private string cor;

public void Pintar( string cor ){

// cor = cor; <- comportamento estranhothis.cor = cor;

}}

Herança

Herança pode ser definida como a capacidade de uma classe herdar

atributos e comportamento de uma outra classe


Herança

• Herança especifica um relacionamento “é um tipo de” entre classes

• Novas classes especializando classes existentes

• A classe derivada herda todos os membros da classe base

Herança

Imposto

ICMS

Classe Deivada

Classe BaseGeneralização

Especialização

Herança

• Hierarquia de classes: classes que derivam de classes derivadas (recomenda-se no máximo de 5 a 7 níveis de herança)

• Herança simples: ocorre quando uma classe é derivada de apenas uma classe

• Herança múltipla: ocorre quando uma classe é derivada de duas ou mais classes

Polimorfismo

Polimorfismo significa “muitas formas” ou o “estado de existir em

muitas formas”


Polimorfismo

• O nome do método reside na classe base (operação)

• A implementação do método reside nas classes derivadas

• Cada implementação pode possuir um comportamento diferente

Polimorfismo

+CalcularValor()

Imposto

+CalcularValor()

ICMS

+CalcularValor()

IPI

PerguntaOrientação a objetos é só isso?

RespostaNão, esses são apenas os quatropilares da OOP

– Abstração– Encapsulamento– Herança – Polimorfismo

Classes Abstratas

• Classes que existem para serem implementadas (classes que derivem dela)

• Não podemos criar instâncias de classes abstratas

• Podemos apenas criar instâncias de classes concretas

• As operações em classes abstratas podem conter implementação

Classes Abstratas

Imposto

ICMS IPI

Classe Abstrata

Classes Concretas

Interfaces

• Interfaces contém apenas operações, sem nenhuma implementação

• Você também não pode criar instâncias de interfaces

• As operações em interfaces não podem conter implementação

• As interfaces devem ser implementadas por classes (derivadas)

• Geralmente as interfaces estão no topo da hierarquia de classes

Interfaces

Imposto

«interface»IImposto

ICMS

Utilizando variáveis do tipo referência

Objetivos

• Utilizando variáveis do tipo referência• Hierarquia de objetos• Classes do .NET Framework• Namespaces em .NET Framework• Conversão de dados do tipo referência

Classe que Iremos Utilizarusing System;

class Pessoa

{

public string nome;

public int idade;

public void Falar( string frase )

{

Console.WriteLine( frase );

}

}

class Homem : Pessoa

{

}

class Mulher : Pessoa

{

}

Exercício

Vamos implementar essas classes pois elas serão utilizadas ao longo deste capítulo

Tipo Valor x Tipo Referência

• Tipo valor– Tipos de dados simples– Exemplo: int, decimal, char, bool, enum, struct– Armazenados na pilha (stack)– Contém diretamente o valor da variável

• Tipo referência– Tipos de dados complexos, mais poderosos (objetos)– Exemplo: SqlConnection, Console, nossas classes– Armazenados na memória dinâmica (heap)– A variável contém uma referência para os dados

(que são armazenados em uma outra área da memória)

Declarando Variáveis do Tipo Referência

• Declarando:Pessoa pes;

• Criando uma instância da classe (objeto):pes = new Pessoa( );

• Declarando e criando em uma única linha:Pessoa pes = new Pessoa( );

• Depois de criado, você pode acessar os membros do objeto através do operador “.”

Você sempre deve instanciar um objeto antes de utilizá-lo,caso contrário receberá uma exceção do tipoNullReferenceException

Destruindo Variáveis do Tipo Referência

• Destruindo explicitamente:

pes = null;

• Destruindo implicitamente:

Apenas deixe o escopo em que a variável está contida terminar.

Variáveis do Tipo Referência

using System;

class CreateAndDestroy{


Pessoa pes = new Pessoa( );pes.nome = "João";pes.idade = 25;pes = null;

}}

Comparando Variáveis

• Value types:==!= comparam os valores

• Reference types:== != comparam as referências, não os valores

Para os tipos de referência não podemos utilizaros outros operadores relacionais (<,>,<= e >=)

Comparando VariáveisExemplo

using System;

class Comparing

{

static void Main( )

{

Pessoa pes1 = new Pessoa( );

pes1.nome = "João";

Pessoa pes2 = new Pessoa( );


if ( pes1 == pes2 )

Console.WriteLine( "Iguais" );

else

Console.WriteLine( "Diferentes" );

}

}

Referências Para o Mesmo Objeto

• Duas referências podem “apontar” para o mesmo objeto

• Variáveis do tipo referência mantém uma referência para os dados

• Duas maneiras de acessar o mesmo objeto para leitura/escrita

Referências Para o Mesmo Objeto

using System;

class MultipleReference{


Pessoa pes1 = new Pessoa( );Pessoa pes2 = pes1;


Console.WriteLine( pes1.nome );Console.WriteLine( pes2.nome );

}}

Exercício

Desenvolver um programa em C# que declara duas variáveis do tipo referência que fazem

referência para o mesmo objeto

Destrua essas variáveis após sua utilização

Parâmetros

• Variáveis do tipo referência aceitam as três formas de passagem de parâmetros:

– Passagem por valor

– Passagem referência

– Parâmetros de saída

Passagem por Valor

• O método recebe uma cópia da referência (duas “variáveis”)

• Durante a execução do método as duas“variáveis” estarão se referenciando ao mesmo objeto

• Isso significa que qualquer alteração no “parâmetro”, não irá alterar o objeto ao qual ele faz referência

Passagem por ValorExemplo

using System;

class ParamRefByValue{

static void TrocarNome( Pessoa p ){

p.nome = "Leandro";}


Pessoa pes = new Pessoa( );pes.nome = "João";TrocarNome( pes );Console.WriteLine( pes.nome );

}}

Passagem por Referência

• O método recebe a mesma referência (apenas uma “variável”)

• Nesse caso teremos apenas uma referência para o objeto

• Qualquer alteração no parâmetro irá afetar a variável diretamente

Passagem por ReferênciaExemplo

using System;

class ParamRefByRef{

static void TrocarNome( ref Pessoa p ){

p = new Pessoa( );p.nome = "Leandro";

}


Pessoa pes = new Pessoa( );pes.nome = "João";TrocarNome( ref pes );Console.WriteLine( pes.nome );

}}

Parâmetro de Saída

• O método recebe a mesma referência (apenas uma “variável”)

• Nesse caso teremos apenas uma referência para o objeto

• Qualquer alteração no parâmetro irá afetar a variável diretamente

• É o mesmo critério da passagem por referência, com a diferença de que o parâmetro tem que ser alterado

Parâmetro de SaídaExemplo

using System;

class ParamRefByOut{

static void TrocarNome( out Pessoa p ){

p = new Pessoa( );p.nome = "Leandro";

}


Pessoa pes = new Pessoa( );pes.nome = "João";TrocarNome( out pes );Console.WriteLine( pes.nome );

}}

Exercício

Desenvolver um programa em C# que faz uso de parâmetros (por valor, por referência e

parâmetro de saída) com variáveis do tipo referência

Exceções

• Exception é uma classe do .NET Framework

• Somente objetos do tipo Exception (ou derivados) pode ser utilizando nos comandos catch ou throw

• Todas as exceções são derivadas de System.Exception

string

• string é uma classe

• A palavra chave string é um atalho para a classe System.String

• Imutável: depois de definida, a string não pode ser alterada. Quando alterada, na verdade é criada uma nova instância da classe contendo a modificação

• StringBuilder: classe para “construção” de strings otimizada

Propriedades e Métodos

• MétodosInsertCopyConcatTrimToUpperToLowerEquals

• PropriedadesBrackets [ ]Lenght

stringExemplo

public class ClassString{


string celula = "TouchAndThink";

char prim = celula[ 0 ];Console.WriteLine( "Primeiro caracter: " + prim );

int size = celula.Length;Console.WriteLine( "Propriedade Lenght: " + size );

// Verificar demais exemplos na ClassString.cs

}}

Operadores de Comparação de Strings

• Os operadores == e != são sobrecarregados para a classe string e podem ser utilizados na comparação de strings

• O operador == é equivalente ao método String.Equals( )

• O operador != é equivalente ao método ! String.Equals( )

• Os operadores relacionais (<;>,<=,>=) não podem ser utilizados para a classe string

Exercício

Desenvolver um programa em C# que utilize métodos e propriedades da classe string

Hierarquia de Objetos

• Todas as classes no .NET Framework derivam ultimamente de object (direta ou indiretamente)

• O tipo object é um apelido para System.Object

• object é a classe base de todas as classes

• Quando você cria uma classe e não especifica nenhuma classe pai, você está na verdade derivando de object

Métodos Comuns

• Métodos pertencentes a classe object:

– ToSring– Equals– GetType– Finalize

• Você pode sobrescrever esses métodos para fornecer o comportamento desejado

• Todos os objetos possuem esses métodos

Métodos ComunsExemplo

using System;

class CommomMethods{


Pessoa pes = new Pessoa( );Console.WriteLine( pes.ToString( ) );

}}

Reflection

• Obter informações do tipo de objeto em tempo de execução – isso é chamado de reflection

• Gerenciado pelo namespace System.Reflection

• Formas de obter o tipo de um objeto:

– Operador typeof

– Método GetType da classe object

– Classe System.Type. Com esta classe podemos obter informações detalhadas de um objeto (campos, métodos, etc)

ReflectionExemplo

using System;using System.Reflection;

class Reflection{


Type tipo = typeof(Pessoa);Console.WriteLine( "Tipo: {0}", tipo );

Pessoa pes = new Pessoa( );Type tipo2 = pes.GetType( );Console.WriteLine( "Tipo: {0}", tipo2 );

}}

Namespaces

• System.IO: classes para manipulação de arquivos e diretórios

• System.XML: suporte a XML e aos vários padrões desta linguagem (NameSpace, Schemas, XPath, XSLT, DOM)

• System.Data: classes que constituem o ADO.NET (um namespace para cada provider)

• System.Windows.Forms: classes do Windows Forms

• System.Web: classes do ASP.NET

Conversão de DadosValue Types

• Implícita

• Explícita (utilizando o operador cast)

• Classe System.Convert

• Quando explícita pode gerar uma exceção (interessante incluir conversões explícitas em um bloco try...catch...finally)

Conversão de DadosExemplo

using System;

class ConvertingValueType{


// Conversão implícitaint numInt = 10;long numLong;numLong = numInt;

// Conversão explícitaint numInt2;long numLong2 = 10;numInt2 = (int)numLong2;

}}

Conversão de DadosReference Types

• Conversão de filho para pai– Implícita ou explícita– Sempre dá certo– Sempre podemos converter para object

• Conversão de pai para filho– Explícita (requer cast)– Pode gerar uma exeção (InvalidCastException)

• Podemos utilizar operadores cast para conversão de tipo de dado de referência

Conversão de DadosExemplo

using System;

class ConvertingRefenceType{


// Conversão implícita (filho para pai)Homem hm = new Homem( );Pessoa pes;pes = hm; // OU pes = (Pessoa)hm;

// Conversão explícita (pai para filho)Pessoa pes2 = new Pessoa( );Mulher ml = pes2 as Mulher;

}}

Operador is

• Retorna verdadeiro se a conversão pode ser feita (não efetua a conversão efetivamente, apenas testa)

• É um tipo de conversão “é um tipo de”

Operador isExemplo

using System;

class IsOperator

{

static void Main( )

{

Homem hm = new Homem( );

Pessoa pes;

if ( hm is Pessoa )

{

pes = hm;

Console.WriteLine( "É uma pessoa" );

}

else

{

Console.WriteLine( "Não é uma pessoa" );

}

}

}

Operador as

• Conversão entre tipo de dado de referência (mesma coisa que o cast)

• O CLR irá checar se a conversão é válida

• Se ocorrer erro na conversão, não gera exceção apenas retorna null

• Sempre verifique o retorno desse tipo de conversão, senão será gerada uma exceção do tipo NullReferenceException

Operador asExemplo

using System;

class AsOperator{


Pessoa pes = new Pessoa( );Homem hm = pes as Homem;if ( hm == null ){

Console.WriteLine( "Converteu" );}else{

Console.WriteLine( "Não Converteu" );}

}}

object

• O objeto é a base para todas as classes

• Qualquer tipo de dado de referência pode ser convertido para object (implícita ou explicitamente)

• Qualquer tipo de dado de referência pode ser armazenado em object (explicitamente)

objectExemplo

using System;

class ConvertingToObject

{

static void Main( )

{

Pessoa pes = new Pessoa( );

object obj;

// Três maneiras de converter para object

obj = pes;

obj = (object)pes;

obj = pes as object;

// Duas maneiras e converter de object

pes = (Pessoa)obj;

pes = obj as Pessoa;

}

}

Boxing e Unboxing

• Boxing– Conversão de value type em reference type– Pode ser implícito ou explícito– Geralmente ocorre na passagem de

parâmetros

• Unboxing– Conversão de reference type em value type– Tem que ser explicitamente– Pode gerar uma exceção

Boxing e UnboxingExemplo

using System;

public class BoxingUnboxing{


int numero = 10;object box;box = numero; // Boxing Implícitobox = (object)numero; // Boxing ExplícitoConsole.WriteLine( box );

numero = (int)box; // UnboxingConsole.WriteLine( numero );

}}

Exercício

Desenvolver um programa em C# que faça uso de boxing e unboxing

Criando e destruindo objetos

Objetivos

• Utilizando métodos construtores• Utilizando campos somente leitura• Utilizando constantes• Utilizando métodos destrutores

Métodos Construtores

São métodos executados automaticamente quando instanciamos

um objeto

Criando Objetos

• Alocando memória (heap):Utilizamos a palavra chave new

• Chamando o método construtor:Especificar o nome da classe seguido de parênteses

• Os dois passos descritos acima devem ser efetuados um uma única linha

• Todos os objetos seguem essa regra (mesmo que implicitamente)

Construtor Padrão

• Acessibilidade pública• Mesmo nome da classe• Sem tipo de dado de retorno (nem mesmo void)• Sem parâmetros (*)• Inicializa todos os campos• Criado implicitamente pelo compilador se não for

criado explicitamente

(*) o construtor padrão não recebe parâmetros,mas um método construtor pode receberparâmetros

Construtor PadrãoExemplo

using System;

class Pessoa

{

public string nome;

public int idade;

public void Falar( string frase)

{

Console.WriteLine(frase);

}

}

class TestePessoa

{

static void Main()

{

Pessoa pes = new Pessoa();

pes.Falar("Olá");

}

}

Sobrescrevendo o Construtor Padrão

• Podemos criar nossos próprios construtores

• O construtor irá inicializar implicitamente os campos que não forem inicializados explicitamente

• CUIDADO: se a inicialização falhar, não teremos o objeto disponível para uso. Procure não fazer tarefas complexas nessa método

Sobrescrevendo o Construtor Padrão

Exemploclass Pessoa{ public string nome; public int idade;

public Pessoa() { this.nome = "João"; }}

Sobrecarga de Construtores

• Construtores são métodos e podem ser sobrecarregados como qualquer outro método

• Mesmo nome, escopo, mas parâmetros diferentes

• CUIDADO: se você escrever um construtor, o compilador não criará um construtor padrão. Você terá que escrever um explicitamente

Sobrecarga de Construtores Exemplo

class Pessoa{ public string nome; public int idade;

public Pessoa( string nome ) { this.nome = nome; }}

Variáveis Somente Leitura

• Sintaxe:

readonly char sexo;

• Regras para inicialização:

– São inicializadas implicitamente– Podem ser inicializadas na declaração– Podem ser inicializadas no método construtor

• Não podem ser alteradas

Constantes

• Sintaxe:

const char sexo = ‘M’;

• Seguem as mesmas regras das variáveis somente leitura

Construtores Privados

• Construtor privado impede da classe de ser instanciada

• Métodos da instância não pode ser executados, apenas métodos estáticos

• Um método interessante de programarmos nossas antigas funções

• O compilador não irá gerar um construtor padrão

Construtores PrivadosExemplo

using System;

class Funcoes{ private Funcoes() { }

public static int Soma(int num1, int num2) { return (num1 + num2); }}

Construtores Estáticos

• Pode ser utilizado para inicializar campos estáticos

• Executado pelo “class loader”

• Executado antes do construtor da instância

• Não pode ser executado

• Não pode ter modificador de tipo de acesso

• Não pode ter parâmetros

• Não pode conter a palavra chave this

Construtores EstáticosExemplo

using System;

class Aplicacao{ public static string nomeUsuario; public static string razaoSocial;

static Aplicacao(){

nomeUsuario = "João"; razaoSocial = "Razão Social"; }}

Tempo de Vida de Variáveis

• Tipo Valor– Passa a existir na declaração– Destruída no final do escopo

• Tipo Referência– Passa a existir na declaração– Destruída pelo Garbage Collection

Garbage Collection

• Irá destruir e recuperar a memória dos objetos que não estão mais utilizados

• Somente objetos que não podem mais ser referenciados são destruídos

• Irá disparar o método Finalize do objeto que está sendo destruído

Destrutores

• Sem modificador de tipo de acesso• Sem tipo de dado de retorno (nem mesmo void)• Mesmo nome da classe com prefixo ~• Sem parâmetros

• Não podemos executar ou sobrescrever o método Finalize

• O compilador irá converter o método destrutor em um método Finalize

DestrutoresExemplo

using System;

class Pessoa{

~Pessoa() {

Console.WriteLine("Destrutor"); }}

using

• Sintaxe:

using (SqlConnection con = new SqlConnection( ) ) {

string strConexao = "";con.ConnectionString = strConexao;con.Open();

}

• O objeto será destruído no final do bloco de comandos

• A classe deve implementar a interface System.IDisposable

Herança em C#

Objetivos

• Derivando classes• Implementando métodos• Utilizando classes seladas• Utilizando interfaces• Utilizando classes abstratas

Herança

• O operador de herança em C# é o “:”

• A classe derivada herda a maioria dos membros da classe pai (menos os construtores e destrutores)

• A classe base deve ser desenhada para suportar herança

• A classe derivada não pode ser mais acessível do que a classe pai

• C# não suporte herança múltipla

Classe baseclass Pessoa{ public Pessoa() { }

public Pessoa( string nome ) { this.nome = nome; }

public void Falar( string frase ) { Console.WriteLine(frase); }}

HerançaExemplo

class Homem : Pessoa{}

class Mulher : Pessoa{}

class TestePessoas{ static void Main() { Homem hm = new Homem( ); hm.Falar("Olá");

}}

Protected

• É um modificador de tipo de acesso

• Apenas a própria classe e derivadas podem acessar os membros com esse modificador de tipo de acesso

• É como um modificador public para as classes derivadas e como private para classes externas

• Membros protected são implicitamente protected nas classes derivadas

• Não pode ser utilizado em estruturas

ProtectedExemplo

class Pessoa{ protected string nome; protected int idade;

.

.

.}

Construtor Base

• É possível executar o método construtor da classe base. Para isso:

– A declaração do construtor deve utilizar a palavra chave base

– Não é possível acessar construtores privados

• Podemos utilizar a palavra chave base para acessar membros da classe pai

• O compilador irá efetuar uma chamada implícita ao construtor da classe base se isso não for feito explicitamente.

• Cuidado com parâmetros na execução explícita de métodos na classe base

Construtor BaseExemplo

class Homem : Pessoa{ public Homem( string nome ) : base ( nome ) { }}

class Mulher : Pessoa{ public Mulher( string nome ) : base ( nome ) { }}

Métodos Virtuais

• Métodos que podem ser sobrescritos

• Métodos não virtuais não podem ser sobrescritos

• Utilizados para implementar polimorfismo

• Método deve possuir implementação

• Métodos virtuais não podem ser estáticos

• Métodos virtuais não podem ser privados

Métodos VirtuaisExemplo

class Pessoa{

public virtual void Falar( string frase ){

Console.WriteLine(frase);}

}

Sobrescrevendo Métodos• Especificar uma nova implementação para um método definido como

virtual

• Utiliza a palavra chave override

• O método deve possuir implementação

• Os métodos devem possuir a mesma assinatura (virtual e override)

• Você pode sobrescrever um método sobrescrito

• Você não pode utilizar override junto com virtual (override é implicitamente virtual)

• override não pode ser utilizado junto com private ou static

Sobrescrevendo MétodosExemplos

class Mulher : Pessoa{

public override void Falar(string frase){

Console.WriteLine(frase);Console.WriteLine(frase);

}}

Escondendo Métodos

• Fazer uso da palavra chave new para especificar uma nova implementação para um método

• “Esconde” métodos virtuais e não virtuais

• “Esconde” métodos que tenham a mesma assinatura

• Você pode utilizar new junto com virtual

• new também pode ser utilizado em campos

Escondendo MétodosExemplo

class Mulher : Pessoa{ public new void Falar(string frase) { Console.WriteLine(frase + " - " + frase); }}

Classes Seladas

• Classes seladas são classes que não podem ser derivadas

• Existem classes que não foram desenhadas para serem derivadas

• Faça isso através da palavra chave sealed

• A classe System.String é uma classe selada

Classes SeladasExemplo

sealed class Homem : Pessoa{ public Homem( string nome ) : base ( nome ) { }}

sealed class Mulher : Pessoa{ public Mulher( string nome ) : base ( nome ) { }}

Criando Interfaces

• “É uma classe sem código”

• Sintaxe semelhante a declaração de uma classe

• Utilizar a palavra chave interface no lugar da palavra chave class

• Especifica um contrato que as classes que forem derivar a interface tem que implementar

• Recomenda-se utilizar o prefixo “I” para nomear interfaces (padrão)

Criando Interfaces (cont.)

• Contém apenas as assinaturas dos métodos (sem modificadores de tipo de acesso)

• Os métodos das interfaces são públicos por padrão (mas não podem conter public explicitamente)

• Os métodos de uma interface não podem conter implementação

• Interfaces também podem conter propriedades, eventos e indexers (todos sem implementação)

Criando InterfacesExemplo

interface IPessoa{ void Falar( string frase );}

Implementando Interfaces

• Uma classe pode implementar zero ou mais interfaces

• Uma interface pode derivar de zero ou mais interfaces

• A classe pode ser mais acessível que a interface(s) que ela implementa

• Uma interface não pode ser mais acessível que a(s) interface(s) base(s)

• A classe deve implementar todos os métodos das interfaces que estão sendo implementadas direta ou indiretamente (mesmo tipo de retorno, nome e parâmetros)

• Uma forma de implementar herança múltipla

Implementando InterfacesExemplo

class Pessoa : IPessoa{ public virtual void Falar( string frase ) { Console.WriteLine(frase); }}

Classes Abstratas

• São classes que não podem ser instanciadas apenas derivadas

• Utilizar a palavra chave abstract

• Mesma sintaxe de classes não abstratas (classes concretas)

• Pode conter implementação e métodos

• Podem implementar interface(s)

Classes AbstratasExemplo

abstract class Pessoa : IPessoa{ protected string nome; protected int idade;

public Pessoa() { }

public Pessoa( string nome ) { this.nome = nome; }

public virtual void Falar( string frase ) { Console.WriteLine(frase); }}

Classes Abstratas X Interfaces

• Ambas existem para serem derivadas

• Ambas não podem ser implementadas

• Ambas não podem ser seladas

• Interfaces não podem conter implementação (classes abstratas podem)

• Interfaces não podem declarar membros não públicos

• Interfaces só podem derivar interfaces

Agregação, namespace e escopo avançado

Objetivos

• Utilizando o modificador de tipo de acesso internal

• Utilizando agregação• Revisando escopo• Utilizando namespaces• Utilizando assemblies

internal• internal é um modificador de tipo de acesso assim como public,

private e protected

• Os membros especificados como internal são públicos para o assembly atual e privados para assemblies externos

• Pode ser utilizado no escopo global

• Pode ser utilizando em classes, métodos e campos

• Modificador de tipo de acesso padrão das classes

• Não pode ser utilizado em estruturas

• Não pode ser utilizado em métodos destrutores

Modificadores de Tipos de Acesso

• public

• private

• protected

• internal

• protected internal

internalExemplo

using System;

internal class InternalAccess{

internal string nome = "João";


InternalAccess i = newInternalAccess( );Console.WriteLine( i.nome );

}}

Agregação

• Uma das características da orientação a objetos

• É um relacionamento entre objetos (com multiplicidade)

• Objetos complexos são construídos a partir de objetos simples

AgregaçãoExemplo

using System;

class Porta{

public string cor;}class Janela{

public string modoAbrir;}class Casa{

public Porta portaCasa;public Janela janelaCasa;

}

Revisando Escopo

• Escopo determina o tempo de vida de variáveis locais

• Determina a região do programa que podemos nos referir a nomes sem qualificação (this, base) principalmente quando temos variáveis com mesmo nome em escopos diferentes

• Determinado pelo { } (menos o escopo global)

Revisando EscopoExemplo

• Quais escopos temos no exemplo abaixo?

class Casa

{public Porta portaCasa = new Porta( );public Janela janelaCasa = new Janela( );


Casa cas = new Casa( );cas.portaCasa.Abrir( );cas.janelaCasa.Abrir( );

}}

namespaces• Utilizados para resolver problemas de conflito entre classes com

mesmo nome

• Organização lógica de classes

• É ideal que classes para um mesmo propósito sejam criadas em um mesmo namespace

• Namespaces podem ser criados em diversos arquivos (cada classe pode estar em um arquivo fonte diferente)

• Você não pode especificar um modificador de tipo de acesso para um namespaces (eles são públicos por padrão)

• Shortland

Declarando namespacesnamespace Empresa{

namespace Construcao{

class Porta{

public string cor;

public void Abrir( ){

Console.WriteLine( "Abir porta" );}

}}

}

namespaces

• Nome qualificado de uma classe deve conter o namespace no qual a classe está contida

• Nomes não qualificados somente podem ser utilizados no mesmo escopo do namespace

• Quando uma classe é definida dentro de um namespace, temos que utilizar o nome qualificado quando formos acessá-la (menos quando estivermos dentro do namespace)

• Podemos aninhar namespaces (namespaces dentro de namespaces)

using

• Traz o nampespace para o escopo atual

• Pode ser utilizado para namespaces aninhados

• Deve ser a(s) primeira(s) instrução(ões) do programa (escopo global)

• Podemos criar alias para um namespace. Ex:

using Lista = System.Collections.ArrayList;Lista lst = new Lista( );

• O alias pode ser criado para outros namespaces e para classes

usingExemplo

using System;using Empresa.Construcao;

class ExemploCasa{


Casa minhaCasa = new Casa( );minhaCasa.janelaCasa.Abrir( );minhaCasa.portaCasa.Abrir( );

}}

namespacesDicas

• Utilizar PascalCasing

• Prefixo do nome da empresa

• Utilizar plural quando necessário

• Evitar nomes de classes iguais a nome de namespaces

• Exemplo:

NomeEmpresa.EstoqueLogistica

assembly

• Conjunto de classes que interagem entre si

• Um assembly pode conter várias classes (lembrar do modificador de acesso internal)

• É uma “DLL”

• Reutilizável, versionável, seguro e auto-descritivo

• Existem dois tipos de assemblies: privados e públicos

assembly• Composto logicamente por:

– Conjunto de tipos (classes) e recursos

– Metadados (manifest)

• Manifest é composto por:

– Identidade: nome, número de versão, cultura (opcional) e uma chaves pública (opcional)

– Conteúdo: informações sobre o conteúdo do assembly

– Dependências: dependências do assembly

assemblyExemplo

using System;

class Calculadora{

public int Soma( int num1, int num2 ){

return ( num1 + num2 );}public int Subtracao( int num1, int num2 ){

return ( num1 - num2 );}

}

version

• Cada assembly possui um número de versão como parte de sua identidade

• O número de versão de um assembly é composto e quatro partes:

<major version>.<minor version>.<build number>.<revision>

• Exemplo:

1.5.1254.0

Operadores, delegações e eventos

Operadores

• Os operadores em C# são métodos especiais

• Possuem sintaxe diferente para clareza

• Existem uma série de operadores pré-definidos

• Podem ser utilizados em classes e estruturas

• O mesmo operador pode possuir comportamento diferente dependendo do tipo de dado (o operador + por exemplo)

Operadores Pré-DefinidosCategoria Operador

Aritmético +, -, *, /, %

Lógico &, |, &&, ||, !, ^, true, false

Concatenação de string +

Incremento e decremento ++, --

Relacional ==, !=, <, >, <=, >=

Atribuição =, +=, -=, *=, /=, %=

Acesso a membros .

Indexação [ ]

Conversão ( )

Condicional ?:

Concatenação e remoção de delegações +, -

Criação de objetos new

Informações de tipo is, sizeof, typeof

Controle de exceções do tipo de overflow checked, uncheck

Indireção e endereçamento *, ->, [ ], &

Sobrecarga de Operadores

• Podemos sobrecarregar os operadores (assim como métodos) para operações com nossas classes e estruturas

• Nem todos os operadores podem ser sobrecarregados:

– Operadores aritméticos, lógicos e binários podem ser sobrecarregados livremente

– O operador de atribuição não pode ser diretamente

Sobrecarga de Operadores

• Sintaxe:

operatorop

op é o operador que será sobrecarregado

• Devem ser métodos públicos e estáticos

• Devem seguir o padrão operatorop

Sobrecarga de OperadoresExemplo

public static decimal operator+( ContaCorrente conta1, ContaCorrente conta2 )

{return ( conta1.Saldo( ) + conta2.Saldo( ) );

}

public static decimal operator-( ContaCorrente conta1, ContaCorrente conta2 )

{return ( conta1.Saldo( ) - conta2.Saldo( ) );

}

Sobrecarga de OperadoresRelacionais

• Sempre devem ser sobrcarregados em pares:– < e >– <= e >=– == e !=

• Sobrecarregar o método Equals quando sobrecarreg == e != (para efeitos de consistência)

• Sobrecarregar o método GetHasCode se sobrecarregar o método Equals

• Equals e GetHasCode são métodos herados de objet

Sobrecarga de OperadoresRelacionais

Exemplo

public static bool operator>( ContaCorrente conta1, ContaCorrente conta2 )

{return ( conta1.Compare( conta2 ) > 0 );

}

public static bool operator<( ContaCorrente conta1, ContaCorrente conta2 )

{return ( conta1.Compare( conta2 ) < 0 );

}

Sobrecarga de OperadoresConversão

• Podemos sobrecarregar operadores de conversão– Explícitos ( palavra chave explicit)– Implícitos (palavra chave implicit)

• Se a classe sobrecarregar um operador de conversão de string a classe deve também deve sobrecarregar o método ToString( )

• Assim como métodos, podemos sobrecarregar os operadores várias vezes, desde que tenham assinaturas diferentes (paramêtros)

• Se um operador de conversão puder gerar uma exceção, defina-o como explícito

Sobrecarga de OperadoresExemplo

public static decimal operator+( ContaCorrente conta1, decimal valor )

{return ( conta1.Saldo( ) + valor );

}

Delegações

• Delegações permitir métodos serem executados indiretamente

• Contém uma referência para um método de um objeto

• Todos os métodos de uma delegação devem ter a mesma assinatura (parâmetros e tipo de dado de retorno)

• Sintaxe semelhante a sintaxe de métodos

DelegaçõesExemplo

public delegate void LigarBomba( );...class BombaEletrica{

public void LigarBomaElerica( ){

Console.WriteLine( "Ligar Bomba Elétrica" );}

}...BombaEletrica be = new BombaEletrica( );LigarBomba ligar new = LigarBomba(be.LigarBomaElerica);ligar( );

Eventos

• Baseado em delegações

• Esquema:

– Publicador: provoca o evento para alertar objetos interessados

– Assinante(s): fornece um método para ser executado quando um evento for executado

EventosExemplo

public delegate void LigarBomba( );public event LigarBomba LigarBombas;

BombaEletrica be = new BombaEletrica( );LigarBombas += new LigarBomba( be.LigarBomaElerica );

BombaMecanica bm = new BombaMecanica( );LigarBombas += new LigarBomba( bm.LigarBombaMecanica );

LigarBombas( );

EventosPassagem de parâmetros

• Parâmetros para eventos sempre devem ser passados como EventArgs (ou derivados)

• Métodos disparados por eventos sempre recebem dois parâmetros: object (sender) e uma referência para um tipo EventArgs (ou derivado) com informações sobre o evento

• Ver exemplo e WindowsApplication

Propriedades e Indexadores

Objetivos

• Utilizando propriedades• Utilizando indexadores

Propriedades

• Utilizadas para acessar campos de uma classe onde precisamos de processamento adicional antes de modificar / recuperar o valor do campo

• Possuem sintaxe semelhante a sintaxe dos campos

• Podemos criar campos somente leitura / escrita utilizando propriedades (através dos blocos get/set)

• É ideal que sejam utilizadas para acessos a campos privados das classes

• Podem utilizar virtual, override e abstract

Propriedades

• Sintaxe:

[modificador acesso] [tipo de dado] [nome propriedade]{

get{

[código]return [nome do campo];

}set{

[código][nome do campo] = value;

}}

PropriedadesExemplo

private string email;

public string EMail{

get{

return ( this.email );}set{

this.email = value;}

}

PropriedadesDicas

• Definir os campos da classe como privados

• Utilizar propriedades para acessar esses campos

• Faça isso principalmente para as classes de negócios (mapeamento objeto relacional)

• Gerar exceções, quando necessário, para o bloco SET

Indexadores

• Transformam o objeto em uma “matriz”

• Possuem sintaxe semelhante as propriedades

• Utiliza a palavra chave this como nome e colchetes (da mesma forma que uma matriz)

• Os elementos podem ser acessados por uma chave inteira (mais comum) e outros tipos de dados (mais incomum/complexo)

IndexadoresExemplo

public class Indexer{

private string[] nomes;

public Indexer( int numNomes ){

this.nomes = new string[ numNomes ];}

public Indexer( ) : this( 1 ){}

public string this[ int posNome ]{

get{

return ( (string)this.nomes[ posNome ] );}set{

this.nomes[ posNome ] = value;}

}}

IndexadoresExemplo

public class MyCollection : CollectionBase{

public string this[ int posNome ]{

get{

return ( (string)List[ posNome ] );}set{

List[ posNome ] = value;}

}

public void Add( string nome ){

List.Add( nome );}

public void Remove( string nome ){

List.Remove( nome );}

}

Atributos

Objetivos

• Entender o que são atributos

Atributos

• Um atributo é uma classe que pode incluir dados adicionais dentro de um assembly

• Podem ser utilizados em qualquer membro da classes (depende do atributo)

• Pode ser utilizado para vários propósitos:– Depuração– Fornecer informações do assembly– Marcação de métodos e classes como obsoletos– Compilação condicional– Acesso ao banco de dados– Definidos pelo usuário

Conditional

using System;using System.Diagnostics;

class TestConditional{


TestConditional tc = new TestConditional( );

tc.TouchOnly( );}

[Conditional("TOUCH")]public void TouchOnly( ){

Console.WriteLine( "Só serei mostrado com a constante TOUCH definida." );}

}

Atributos

• [Serializable]

• [NonSerializable]

• [WebMethod]

• [STAThread]

• [Obsolete]

Alguma Promessa Pendente???

Curso de C#

Documents

Transcript of Curso de C#