curso de c#
DESCRIPTION
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. - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/1.jpg)
Curso de C#
![Page 2: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/2.jpg)
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
![Page 3: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/3.jpg)
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
![Page 4: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/4.jpg)
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
![Page 5: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/5.jpg)
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
![Page 6: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/6.jpg)
Visão geral de C#
![Page 7: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/7.jpg)
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#
![Page 8: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/8.jpg)
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
![Page 9: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/9.jpg)
Hello World
using System;class Hello{
public static void Main( ){
Console.WriteLine(“Hello World”);}
}
![Page 10: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/10.jpg)
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( );
![Page 11: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/11.jpg)
Exercício
Vamos utilizar o Microsoft Visual Studio 2005 para desenvolver o programa Hello World
![Page 12: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/12.jpg)
Tipos de Comentários
• Comentando uma única linha– //
• Comentário várias linhas– /* ... */
• Documentação XML– ///
![Page 13: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/13.jpg)
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" );}
}
![Page 14: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/14.jpg)
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
![Page 15: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/15.jpg)
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
![Page 16: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/16.jpg)
Exercício
Gerando a documentação XML de um programa escrito em C#
![Page 17: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/17.jpg)
Compilando
• Através do Microsoft Visual Studio:->Menu Build
-> Build Solution
• Através da janela de comando:csc /out:meuprograma.exe meuprograma.cs
![Page 18: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/18.jpg)
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)
![Page 19: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/19.jpg)
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
![Page 20: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/20.jpg)
Exercício
Compilar, executar e depurar um programa escrito em C#
![Page 21: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/21.jpg)
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
![Page 22: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/22.jpg)
Demonstração
Utilizando o utilitário de linha de comando ILDASM para verificar código MSIL
![Page 23: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/23.jpg)
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
![Page 24: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/24.jpg)
Utilizando variáveis do tipo valor
![Page 25: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/25.jpg)
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
![Page 26: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/26.jpg)
Commom Type System
• Parte do CLR (Commom Language RunTime)
• Compartilhado entre todas as linguagens .NET
• Tipos de variáveis:– Value types– Reference types
![Page 27: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/27.jpg)
Value Types
• Existem dois tipos de value types
– Built-in types (Simple types)intfloat
– User defined typesenumstruct
![Page 28: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/28.jpg)
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
![Page 29: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/29.jpg)
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
![Page 30: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/30.jpg)
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
![Page 31: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/31.jpg)
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
![Page 32: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/32.jpg)
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;
![Page 33: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/33.jpg)
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
![Page 34: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/34.jpg)
“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
![Page 35: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/35.jpg)
Operadores
Operador ExemploComparação == !=
Relacionais < > <= >= is
Condicionais && || ?:
Incremento ++
Decremento --
Aritimético + - * / %
Atribuição = *= /= %= += -=
![Page 36: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/36.jpg)
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 “-”
![Page 37: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/37.jpg)
Incremento e Decremento
• Existem duas formas:
num1++;++num1;
• Exemplos:
int numero = 10;int preresultado = ++numero; // preresulatdo =11int posresultado = numero++; // preresulatdo =11
![Page 38: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/38.jpg)
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 )
![Page 39: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/39.jpg)
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
![Page 40: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/40.jpg)
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
![Page 41: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/41.jpg)
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 );
![Page 42: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/42.jpg)
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;
![Page 43: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/43.jpg)
Exercício
Desenvolver um programa em C# que faça uso de enumerações e estruturas
![Page 44: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/44.jpg)
Convertendo Variáveis
• C# suporta dois tipos de conversão:
– Conversão implícita de dados
– Conversão explícita dedados
![Page 45: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/45.jpg)
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
![Page 46: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/46.jpg)
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
![Page 47: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/47.jpg)
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 );
}
![Page 48: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/48.jpg)
Exercício
Desenvolver um programa em C# que faça conversão implícitas e explícitas de variáveis
![Page 49: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/49.jpg)
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
![Page 50: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/50.jpg)
Comandos e exceções
![Page 51: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/51.jpg)
Objetivos
• Utilizar bloco de comandos• Utilizar comandos de seleção• Utilizar comandos de repetição• Tratamento de exceções
![Page 52: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/52.jpg)
Bloco de comandos
• Delimitado por { }• Você pode “aninhar” blocos• Exemplo:{
{int numero;numero = 5;
}}
![Page 53: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/53.jpg)
Exemplo 1
{int numero;numero = 5;Console.WriteLine( "{0}", numero );
}Console.WriteLine( "{0}", numero );{
int numero;numero = 10;Console.WriteLine( "{0}", numero );
}
![Page 54: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/54.jpg)
Exemplo 2
{int numero;{
int numero;numero = 5;Console.WriteLine( "{0}", numero );
}}
![Page 55: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/55.jpg)
Tipos de comandos
• Seleçãoif e switch
• Repetiçãowhile, do, for e foreach
• Quebra e continuidadebreak e continue
![Page 56: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/56.jpg)
if
Sintaxe:
if (expressão booleana)bloco de comandos do if
elsebloco de comandos do else
![Page 57: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/57.jpg)
if – exemplo 1
int numero = int.Parse( Console.ReadLine( ) );
if ( numero % 2 == 0 )Console.WriteLine( "PAR" );
elseConsole.WriteLine( "ÍMPAR" );
![Page 58: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/58.jpg)
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" );
![Page 59: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/59.jpg)
if – exemplo 3
int numero = int.Parse( Console.ReadLine( ) );
if ( numero < 10 )numero++;Console.WriteLine( numero );Console.WriteLine( "Menor que dez" );
![Page 60: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/60.jpg)
if – exemplo 4
int numero = int.Parse( Console.ReadLine( ) );
if ( numero < 10 ){
numero++;Console.WriteLine( numero );Console.WriteLine( "Menor que dez" );
}
![Page 61: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/61.jpg)
Exercício
Escolha um dos exemplos apresentados do comando if e coloque-o em prática
![Page 62: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/62.jpg)
switch
Sintaxe:
switch ( variável ) // integer, char, enum ou string{
case constante1:bloco de comandos
case constante2:bloco de comandos
case constante3:bloco de comandos
default:bloco de comandos
}
![Page 63: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/63.jpg)
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 );
![Page 64: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/64.jpg)
Exercício
Desenvolva um pequeno menu e trata a opção digitada pelo usuário fazendo uso do comando
switch
![Page 65: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/65.jpg)
while
Sintaxe:
while ( expressão booleana ){
bloco de comandos}
![Page 66: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/66.jpg)
while – exemplo 1
int contador = 0;while (contador < 10 ){
contador++;Console.WriteLine( "{0}", contador );
}
![Page 67: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/67.jpg)
while – exemplo 2
int contador = 10;while (contador < 10 ){
contador++;Console.WriteLine( "{0}", contador );
}
![Page 68: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/68.jpg)
do while
Sintaxe:
do {
bloco de comandos}while ( expressão booleana );
![Page 69: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/69.jpg)
do while – exemplo 1
int contador = 0;do{
contador++;Console.WriteLine( "{0}", contador );
}while ( contador < 10 );
![Page 70: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/70.jpg)
do while – exemplo 2
int contador = 10;do{
contador++;Console.WriteLine( "{0}", contador );
}while ( contador < 10 );
![Page 71: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/71.jpg)
for
Sintaxe:
for ( inicialização ; condição ; incremento ){
bloco de comandos}
![Page 72: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/72.jpg)
for – exemplo 1
for ( int i = 1 ; i <= 10 ; i++ ){
Console.WriteLine( "{0}", i );}
![Page 73: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/73.jpg)
for – exemplo 2
for ( int i = 1 ; i <= 10 ; i++ ){
Console.WriteLine( "{0}", i );}Console.WriteLine( "{0}", i );
![Page 74: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/74.jpg)
for – exemplo 3
for ( int i = 1, k = 1 ; i <= 10 ; i++, k++ ){
Console.WriteLine( "{0}", i );Console.WriteLine( "{0}", k );
}
![Page 75: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/75.jpg)
Exercício
Desenvolva um programa em C# que solicite um número ao usuário e imprima a tabuada desse
número
![Page 76: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/76.jpg)
foreach
Sintaxe:
foreach ( variável in coleção ){
bloco de comandos}
![Page 77: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/77.jpg)
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 );}
![Page 78: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/78.jpg)
continue / break
int i = 0;while ( true ){
i++;if ( i > 10 ) {
break;}else {
Console.WriteLine( i );continue;
}}
![Page 79: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/79.jpg)
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
![Page 80: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/80.jpg)
Exceptions
ExceptionSystemException
OutOfMemoryExceptionIOExceptionNullReferenceException
ApplicationException
![Page 81: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/81.jpg)
try...catch...finally
try{}catch ( OverflowException oe ){}catch ( InvalidCastException ice ){}catch ( Exception e ){}finally{}
![Page 82: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/82.jpg)
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" );}
![Page 83: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/83.jpg)
throw
int minutos = int.Parse( Console.ReadLine( ) );if ( minutos < 1 || minutos >= 60 ){
throw new Exception( "horário inválido" );}
![Page 84: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/84.jpg)
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 );}
![Page 85: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/85.jpg)
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
![Page 86: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/86.jpg)
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)
![Page 87: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/87.jpg)
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
![Page 88: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/88.jpg)
Métodos e parâmetros
![Page 89: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/89.jpg)
Objetivos
• Definir e utilizar métodos estáticos• Passar parâmetros para métodos• Definir e utilizar sobrecarga de métodos
![Page 90: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/90.jpg)
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
![Page 91: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/91.jpg)
MétodosExemplo 1
using System;
class Exemplo{
static void DizerAlo( ){
Console.WriteLine( "Alo" );}public static void Main( ){
DizerAlo( );}
}
![Page 92: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/92.jpg)
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
![Page 93: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/93.jpg)
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{
public static void Main( ){
Um.DizerAlo( );}
}
![Page 94: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/94.jpg)
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( );
}}
![Page 95: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/95.jpg)
Exercício
Desenvolva um programa em C# que possua um método que escreva o seu nome na tela
![Page 96: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/96.jpg)
return
using System;
class Exemplo{
static void Main( ){
Console.WriteLine( "Hello" );return;Console.WriteLine( "World" );
}}
![Page 97: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/97.jpg)
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
![Page 98: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/98.jpg)
VariáveisExemplo 1
using System;
class Exemplo{
static void Contar( ){
numero++;}public static void Main( ){
int numero = 0;Contar( );Console.WriteLine( numero );
}}
![Page 99: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/99.jpg)
VariáveisExemplo 2
using System;
class Exemplo{
static int numero = 0;static void Contar( ){
numero++;}public static void Main( ){
Contar( );Console.WriteLine( numero );
}}
![Page 100: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/100.jpg)
VariáveisExemplo 3
using System;
class Exemplo{
static int numero = 0;static void Contar( ){
numero++;}public static void Main( ){
int numero = 0;Contar( );Console.WriteLine( numero );
}}
![Page 101: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/101.jpg)
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
![Page 102: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/102.jpg)
Retornando valores Exemplo
using System;
class Exemplo{
static int GetNumero( ){
Console.Write( "Digite um número: " );int numero = int.Parse( Console.ReadLine( ) );return ( numero );
}public static void Main( ){
int numero = GetNumero( );Console.WriteLine( numero );
}}
![Page 103: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/103.jpg)
Exercício
Desenvolver um programa em C# que possui um método que retorna a data de hoje e imprima
essa data na tela
![Page 104: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/104.jpg)
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
![Page 105: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/105.jpg)
ParâmetrosExemplo
using System;
class Exemplo{
static void DizerOla( string nome ){
Console.WriteLine( "Ola " + nome );}
public static void Main( ){
string nome = "João";DizerOla( nome );
}}
![Page 106: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/106.jpg)
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
![Page 107: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/107.jpg)
Passagem de Parâmetros
in Passagem por valor
in
out Passagem por referência
out Parâmetros de saída (output)
![Page 108: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/108.jpg)
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
![Page 109: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/109.jpg)
Passagem por valor Exemplo
using System;class Exemplo{
static void SomarUm( int numero ){
numero++;}public static void Main( ){
int num = 1;SomarUm( num );Console.WriteLine( num );
}}
![Page 110: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/110.jpg)
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
![Page 111: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/111.jpg)
Passagem por referência Exemplo
using System;class Exemplo{
static void SomarUm( ref int numero ){
numero++;}public static void Main( ){
int num = 1;SomarUm( ref num );Console.WriteLine( num );
}}
![Page 112: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/112.jpg)
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
![Page 113: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/113.jpg)
Parâmetro de saídaExemplo
using System;class Exemplo{
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( ) );
}public static void Main( ){
string nome;int idade;GetNomeIdade( out nome, out idade );Console.WriteLine( "Nome: " + nome + "\nIdade: " + idade.ToString( ) );
}}
![Page 114: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/114.jpg)
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
![Page 115: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/115.jpg)
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
![Page 116: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/116.jpg)
Lista de parâmetros variada Exemplo
using System;
class Exemplo{
static void Nomes( params string[ ] nomes ){
foreach( string nome in nomes ){
Console.WriteLine( nome );}
}public static void Main( ){
Nomes( "João", “Tiago", "Leonardo", "Rodolfo" );}
}
![Page 117: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/117.jpg)
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
![Page 118: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/118.jpg)
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
![Page 119: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/119.jpg)
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 ) );
}}
![Page 120: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/120.jpg)
Exercício
Desenvolver um programa em C# que faça uso de sobrecarga de métodos
![Page 121: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/121.jpg)
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
![Page 122: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/122.jpg)
Matrizes (vetores)
![Page 123: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/123.jpg)
Objetivos
• Visão geral de matrizes• Criando matrizes• Utilizando matrizes• Coleções
![Page 124: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/124.jpg)
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)
![Page 125: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/125.jpg)
MatrizesExemplo 1
using System;
class Matrizes{
static void Main( ){
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]); }
}}
![Page 126: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/126.jpg)
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
![Page 127: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/127.jpg)
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
![Page 128: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/128.jpg)
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 ];
![Page 129: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/129.jpg)
Alterando Elementos
• Informe o nome da matriz e índice desejado entre colchetes
numeros[ 1 ] = 10;
numeros[ 1, 1 ] = 10;
![Page 130: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/130.jpg)
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
![Page 131: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/131.jpg)
MatrizesExemplo 2
using System;
class Matrizes_2{
static void Main( ){
int[ ] numeros = new int[ 5 ];for ( int i = 0 ; i < 5 ; i++ ){
Console.WriteLine( numeros[ i ] );}
}}
![Page 132: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/132.jpg)
Exercício
Desenvolver um programa em C# que declara e cria matrizes. Acesse e altere os elementos
dessas matrizes
![Page 133: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/133.jpg)
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)
![Page 134: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/134.jpg)
MatrizesExemplo 3
using System;
class Matrizes_3{
static void Main( ){
int[ ] numeros = new int[ 5 ] { 1, 2, 3, 4, 5 };
for ( int i = 0 ; i < 5 ; i++ ){
Console.WriteLine( numeros[ i ] );}
}}
![Page 135: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/135.jpg)
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
![Page 136: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/136.jpg)
MatrizesExemplo 4
using System;
class Matrizes_4{
static void Main( ){
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 ] );}
}}
}
![Page 137: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/137.jpg)
Exercício
Alterar o exercício anterior para inicializar as matrizes criadas
![Page 138: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/138.jpg)
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
![Page 139: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/139.jpg)
MatrizesExemplo 5
using System;
class Matrizes_5{
static void Main( ){
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 ] );}
}}
![Page 140: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/140.jpg)
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
![Page 141: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/141.jpg)
MatrizesExemplo 6
using System;
class Matrizes_6{
static void Main( ){
int[] numeros = { 1, 2, 3, 4, 5 };int[] copiaNumeros = numeros;
copiaNumeros[ 0 ]++;
Console.WriteLine( numeros[ 0 ] );Console.WriteLine( copiaNumeros[ 0 ] );
}}
![Page 142: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/142.jpg)
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
![Page 143: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/143.jpg)
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
![Page 144: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/144.jpg)
MatrizesExemplo 7
using System;
class Matrizes_7{
static void Main( ){
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 );
}}
![Page 145: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/145.jpg)
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
![Page 146: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/146.jpg)
MatrizesExemplo 8
using System;
class Matrizes_8{
static void Main( ){
int[] numeros = new int[ 5 ] { 5, 3, 1, 2, 4 };System.Array.Sort( numeros );for( int i = 0 ; i < numeros.Length ; i++ ){
Console.WriteLine( numeros[ i ] );}
}}
![Page 147: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/147.jpg)
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
![Page 148: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/148.jpg)
Retornando Matrizes de Métodos
using System;
class Matrizes_9{
static void Main( ){
int[] numeros = GetNumeros( );for ( int i = 0 ; i < numeros.Length ; i ++ ){
Console.WriteLine( numeros[ i ] );}
}static int[] GetNumeros( ){
int[] numeros = new int[5] { 1, 2, 3, 4, 5 };return ( numeros );
}}
![Page 149: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/149.jpg)
Passando Matrizes como Parâmetro para Métodos
using System;
class Matrizes_10{
static void Main( ){
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 ++ ){
Console.WriteLine( numeros[ i ] );}
}}
![Page 150: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/150.jpg)
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 ] );}
}}
![Page 151: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/151.jpg)
Percorrendo Matrizes com o comando foreach
using System;
class Matrizes_12{
static void Main( ){
int[] numeros = new int[ 5 ] { 1, 2, 3, 4, 5 };foreach ( int numero in numeros ){
Console.WriteLine( numero );}
}}
![Page 152: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/152.jpg)
Exercício
Alterar o exercício anterior para percorrer a matriz utilizado o comando foreach
![Page 153: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/153.jpg)
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
![Page 154: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/154.jpg)
Coleções
using System;using System.Collections;
public class Colecao{
static void Main( ){
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( ) );}
}}
![Page 155: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/155.jpg)
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
![Page 156: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/156.jpg)
Fundamentos da programação orientada
a objetos
![Page 157: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/157.jpg)
Objetivos
• Classes e objetos• Abstração• Encapsulamento• Membros estáticos• Herança• Polimorfismo• Orientação a objetos em C#
![Page 158: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/158.jpg)
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)
![Page 159: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/159.jpg)
Classe
• Composta por membros:
– Campos (características, propriedades)NomeCorAno
– Métodos (operações)LigarAcelerarBrecar
![Page 160: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/160.jpg)
Objeto
• Um objeto é uma instância (ocorrência) de uma classe
• Exemplo: uma ferrari seria um exemplo de uma instância da classe carro
![Page 161: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/161.jpg)
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)
![Page 162: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/162.jpg)
Tipo Valor x Tipo Referência Exemplo
using System;using System.Collections;
class TipoSimplesReferencia{
static void Main( ){
int numero;numero = 0;
ArrayList lista = new ArrayList( );lista.Add( 0 );
}}
![Page 163: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/163.jpg)
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
![Page 164: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/164.jpg)
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
![Page 165: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/165.jpg)
Encapsulamento
Encapsulamento pode ser definido como a tarefa de tornar um objeto
o mais auto-suficiente possível
Fonte: MSDN Magazine
![Page 166: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/166.jpg)
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)
![Page 167: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/167.jpg)
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 );}
}
![Page 168: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/168.jpg)
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
![Page 169: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/169.jpg)
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
![Page 170: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/170.jpg)
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
![Page 171: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/171.jpg)
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" );}
}
![Page 172: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/172.jpg)
Membros EstáticosExemplo 2
using System;
class PessoaEstatica{
public static void Falar( string frase ){
Console.WriteLine( frase );}
}class TestePessoaEstatica{
static void Main( ){
PessoaEstatica.Falar( "TouchAndThink.NET" );}
}
![Page 173: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/173.jpg)
Exercício
Colocar os exemplos de membros estáticos e não estáticos em prática para perceber a
diferença entre eles
![Page 174: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/174.jpg)
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)
![Page 175: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/175.jpg)
Definição de ClassesExemplo
using System;
class Pessoa{
private string nome;private int idade;private char sexo;
public void Falar( string frase ){
Console.WriteLine( frase );}
}
![Page 176: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/176.jpg)
Exercício
Escrever uma classe em C# que abstrai e encapsula algumas características de um carro
![Page 177: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/177.jpg)
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)
![Page 178: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/178.jpg)
Modificadores Exemplo
using System;
class Pessoa{
private string nome;private int idade;private char sexo;
public void Falar( string frase ){
Console.WriteLine( frase );}
}
![Page 179: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/179.jpg)
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
![Page 180: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/180.jpg)
Criando Objetos Exemplo
using System;
//Definição da classe
class TestePessoa{
static void Main( ){
Pessoa pes1 = new Pessoa( );pes1.Falar( "Oi" );
}}
![Page 181: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/181.jpg)
Exercício
Escrever uma classe que crie objetos da classe carro criada no exercício anterior
![Page 182: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/182.jpg)
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)
![Page 183: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/183.jpg)
this Exemplo
class Carro{
private string cor;
public void Pintar( string cor ){
// cor = cor; <- comportamento estranhothis.cor = cor;
}}
![Page 184: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/184.jpg)
Herança
Herança pode ser definida como a capacidade de uma classe herdar
atributos e comportamento de uma outra classe
Fonte: MSDN Magazine
![Page 185: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/185.jpg)
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
![Page 186: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/186.jpg)
Herança
Imposto
ICMS
Classe Deivada
Classe BaseGeneralização
Especialização
![Page 187: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/187.jpg)
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
![Page 188: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/188.jpg)
Polimorfismo
Polimorfismo significa “muitas formas” ou o “estado de existir em
muitas formas”
Fonte: MSDN Magazine
![Page 189: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/189.jpg)
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
![Page 190: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/190.jpg)
Polimorfismo
+CalcularValor()
Imposto
+CalcularValor()
ICMS
+CalcularValor()
IPI
![Page 191: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/191.jpg)
PerguntaOrientação a objetos é só isso?
RespostaNão, esses são apenas os quatropilares da OOP
– Abstração– Encapsulamento– Herança – Polimorfismo
![Page 192: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/192.jpg)
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
![Page 193: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/193.jpg)
Classes Abstratas
Imposto
ICMS IPI
Classe Abstrata
Classes Concretas
![Page 194: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/194.jpg)
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
![Page 195: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/195.jpg)
Interfaces
Imposto
«interface»IImposto
ICMS
![Page 196: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/196.jpg)
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
![Page 197: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/197.jpg)
Utilizando variáveis do tipo referência
![Page 198: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/198.jpg)
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
![Page 199: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/199.jpg)
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
{
}
![Page 200: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/200.jpg)
Exercício
Vamos implementar essas classes pois elas serão utilizadas ao longo deste capítulo
![Page 201: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/201.jpg)
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)
![Page 202: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/202.jpg)
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
![Page 203: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/203.jpg)
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.
![Page 204: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/204.jpg)
Variáveis do Tipo Referência
using System;
class CreateAndDestroy{
static void Main( ){
Pessoa pes = new Pessoa( );pes.nome = "João";pes.idade = 25;pes = null;
}}
![Page 205: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/205.jpg)
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 >=)
![Page 206: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/206.jpg)
Comparando VariáveisExemplo
using System;
class Comparing
{
static void Main( )
{
Pessoa pes1 = new Pessoa( );
pes1.nome = "João";
Pessoa pes2 = new Pessoa( );
pes2.nome = "João";
if ( pes1 == pes2 )
Console.WriteLine( "Iguais" );
else
Console.WriteLine( "Diferentes" );
}
}
![Page 207: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/207.jpg)
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
![Page 208: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/208.jpg)
Referências Para o Mesmo Objeto
using System;
class MultipleReference{
static void Main( ){
Pessoa pes1 = new Pessoa( );Pessoa pes2 = pes1;
pes1.nome = "João";
Console.WriteLine( pes1.nome );Console.WriteLine( pes2.nome );
}}
![Page 209: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/209.jpg)
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
![Page 210: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/210.jpg)
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
![Page 211: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/211.jpg)
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
![Page 212: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/212.jpg)
Passagem por ValorExemplo
using System;
class ParamRefByValue{
static void TrocarNome( Pessoa p ){
p.nome = "Leandro";}
static void Main( ){
Pessoa pes = new Pessoa( );pes.nome = "João";TrocarNome( pes );Console.WriteLine( pes.nome );
}}
![Page 213: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/213.jpg)
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
![Page 214: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/214.jpg)
Passagem por ReferênciaExemplo
using System;
class ParamRefByRef{
static void TrocarNome( ref Pessoa p ){
p = new Pessoa( );p.nome = "Leandro";
}
static void Main( ){
Pessoa pes = new Pessoa( );pes.nome = "João";TrocarNome( ref pes );Console.WriteLine( pes.nome );
}}
![Page 215: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/215.jpg)
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
![Page 216: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/216.jpg)
Parâmetro de SaídaExemplo
using System;
class ParamRefByOut{
static void TrocarNome( out Pessoa p ){
p = new Pessoa( );p.nome = "Leandro";
}
static void Main( ){
Pessoa pes = new Pessoa( );pes.nome = "João";TrocarNome( out pes );Console.WriteLine( pes.nome );
}}
![Page 217: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/217.jpg)
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
![Page 218: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/218.jpg)
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
![Page 219: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/219.jpg)
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
![Page 220: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/220.jpg)
Propriedades e Métodos
• MétodosInsertCopyConcatTrimToUpperToLowerEquals
• PropriedadesBrackets [ ]Lenght
![Page 221: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/221.jpg)
stringExemplo
public class ClassString{
static void Main( ){
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
}}
![Page 222: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/222.jpg)
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
![Page 223: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/223.jpg)
Exercício
Desenvolver um programa em C# que utilize métodos e propriedades da classe string
![Page 224: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/224.jpg)
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
![Page 225: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/225.jpg)
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
![Page 226: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/226.jpg)
Métodos ComunsExemplo
using System;
class CommomMethods{
static void Main( ){
Pessoa pes = new Pessoa( );Console.WriteLine( pes.ToString( ) );
}}
![Page 227: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/227.jpg)
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)
![Page 228: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/228.jpg)
ReflectionExemplo
using System;using System.Reflection;
class Reflection{
static void Main( ){
Type tipo = typeof(Pessoa);Console.WriteLine( "Tipo: {0}", tipo );
Pessoa pes = new Pessoa( );Type tipo2 = pes.GetType( );Console.WriteLine( "Tipo: {0}", tipo2 );
}}
![Page 229: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/229.jpg)
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
![Page 230: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/230.jpg)
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)
![Page 231: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/231.jpg)
Conversão de DadosExemplo
using System;
class ConvertingValueType{
static void Main( ){
// Conversão implícitaint numInt = 10;long numLong;numLong = numInt;
// Conversão explícitaint numInt2;long numLong2 = 10;numInt2 = (int)numLong2;
}}
![Page 232: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/232.jpg)
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
![Page 233: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/233.jpg)
Conversão de DadosExemplo
using System;
class ConvertingRefenceType{
static void Main( ){
// 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;
}}
![Page 234: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/234.jpg)
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”
![Page 235: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/235.jpg)
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" );
}
}
}
![Page 236: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/236.jpg)
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
![Page 237: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/237.jpg)
Operador asExemplo
using System;
class AsOperator{
static void Main( ){
Pessoa pes = new Pessoa( );Homem hm = pes as Homem;if ( hm == null ){
Console.WriteLine( "Converteu" );}else{
Console.WriteLine( "Não Converteu" );}
}}
![Page 238: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/238.jpg)
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)
![Page 239: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/239.jpg)
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;
}
}
![Page 240: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/240.jpg)
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
![Page 241: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/241.jpg)
Boxing e UnboxingExemplo
using System;
public class BoxingUnboxing{
static void Main( ){
int numero = 10;object box;box = numero; // Boxing Implícitobox = (object)numero; // Boxing ExplícitoConsole.WriteLine( box );
numero = (int)box; // UnboxingConsole.WriteLine( numero );
}}
![Page 242: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/242.jpg)
Exercício
Desenvolver um programa em C# que faça uso de boxing e unboxing
![Page 243: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/243.jpg)
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
![Page 244: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/244.jpg)
Criando e destruindo objetos
![Page 245: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/245.jpg)
Objetivos
• Utilizando métodos construtores• Utilizando campos somente leitura• Utilizando constantes• Utilizando métodos destrutores
![Page 246: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/246.jpg)
Métodos Construtores
São métodos executados automaticamente quando instanciamos
um objeto
![Page 247: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/247.jpg)
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)
![Page 248: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/248.jpg)
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
![Page 249: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/249.jpg)
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á");
}
}
![Page 250: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/250.jpg)
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
![Page 251: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/251.jpg)
Sobrescrevendo o Construtor Padrão
Exemploclass Pessoa{ public string nome; public int idade;
public Pessoa() { this.nome = "João"; }}
![Page 252: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/252.jpg)
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
![Page 253: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/253.jpg)
Sobrecarga de Construtores Exemplo
class Pessoa{ public string nome; public int idade;
public Pessoa( string nome ) { this.nome = nome; }}
![Page 254: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/254.jpg)
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
![Page 255: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/255.jpg)
Constantes
• Sintaxe:
const char sexo = ‘M’;
• Seguem as mesmas regras das variáveis somente leitura
![Page 256: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/256.jpg)
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
![Page 257: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/257.jpg)
Construtores PrivadosExemplo
using System;
class Funcoes{ private Funcoes() { }
public static int Soma(int num1, int num2) { return (num1 + num2); }}
![Page 258: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/258.jpg)
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
![Page 259: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/259.jpg)
Construtores EstáticosExemplo
using System;
class Aplicacao{ public static string nomeUsuario; public static string razaoSocial;
static Aplicacao(){
nomeUsuario = "João"; razaoSocial = "Razão Social"; }}
![Page 260: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/260.jpg)
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
![Page 261: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/261.jpg)
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
![Page 262: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/262.jpg)
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
![Page 263: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/263.jpg)
DestrutoresExemplo
using System;
class Pessoa{
~Pessoa() {
Console.WriteLine("Destrutor"); }}
![Page 264: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/264.jpg)
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
![Page 265: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/265.jpg)
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
![Page 266: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/266.jpg)
Herança em C#
![Page 267: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/267.jpg)
Objetivos
• Derivando classes• Implementando métodos• Utilizando classes seladas• Utilizando interfaces• Utilizando classes abstratas
![Page 268: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/268.jpg)
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
![Page 269: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/269.jpg)
Classe baseclass Pessoa{ public Pessoa() { }
public Pessoa( string nome ) { this.nome = nome; }
public void Falar( string frase ) { Console.WriteLine(frase); }}
![Page 270: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/270.jpg)
HerançaExemplo
class Homem : Pessoa{}
class Mulher : Pessoa{}
class TestePessoas{ static void Main() { Homem hm = new Homem( ); hm.Falar("Olá");
}}
![Page 271: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/271.jpg)
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
![Page 272: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/272.jpg)
ProtectedExemplo
class Pessoa{ protected string nome; protected int idade;
.
.
.}
![Page 273: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/273.jpg)
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
![Page 274: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/274.jpg)
Construtor BaseExemplo
class Homem : Pessoa{ public Homem( string nome ) : base ( nome ) { }}
class Mulher : Pessoa{ public Mulher( string nome ) : base ( nome ) { }}
![Page 275: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/275.jpg)
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
![Page 276: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/276.jpg)
Métodos VirtuaisExemplo
class Pessoa{
public virtual void Falar( string frase ){
Console.WriteLine(frase);}
}
![Page 277: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/277.jpg)
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
![Page 278: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/278.jpg)
Sobrescrevendo MétodosExemplos
class Mulher : Pessoa{
public override void Falar(string frase){
Console.WriteLine(frase);Console.WriteLine(frase);
}}
![Page 279: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/279.jpg)
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
![Page 280: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/280.jpg)
Escondendo MétodosExemplo
class Mulher : Pessoa{ public new void Falar(string frase) { Console.WriteLine(frase + " - " + frase); }}
![Page 281: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/281.jpg)
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
![Page 282: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/282.jpg)
Classes SeladasExemplo
sealed class Homem : Pessoa{ public Homem( string nome ) : base ( nome ) { }}
sealed class Mulher : Pessoa{ public Mulher( string nome ) : base ( nome ) { }}
![Page 283: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/283.jpg)
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)
![Page 284: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/284.jpg)
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)
![Page 285: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/285.jpg)
Criando InterfacesExemplo
interface IPessoa{ void Falar( string frase );}
![Page 286: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/286.jpg)
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
![Page 287: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/287.jpg)
Implementando InterfacesExemplo
class Pessoa : IPessoa{ public virtual void Falar( string frase ) { Console.WriteLine(frase); }}
![Page 288: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/288.jpg)
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)
![Page 289: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/289.jpg)
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); }}
![Page 290: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/290.jpg)
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
![Page 291: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/291.jpg)
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
![Page 292: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/292.jpg)
Agregação, namespace e escopo avançado
![Page 293: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/293.jpg)
Objetivos
• Utilizando o modificador de tipo de acesso internal
• Utilizando agregação• Revisando escopo• Utilizando namespaces• Utilizando assemblies
![Page 294: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/294.jpg)
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
![Page 295: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/295.jpg)
Modificadores de Tipos de Acesso
• public
• private
• protected
• internal
• protected internal
![Page 296: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/296.jpg)
internalExemplo
using System;
internal class InternalAccess{
internal string nome = "João";
static void Main( ){
InternalAccess i = newInternalAccess( );Console.WriteLine( i.nome );
}}
![Page 297: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/297.jpg)
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
![Page 298: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/298.jpg)
AgregaçãoExemplo
using System;
class Porta{
public string cor;}class Janela{
public string modoAbrir;}class Casa{
public Porta portaCasa;public Janela janelaCasa;
}
![Page 299: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/299.jpg)
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)
![Page 300: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/300.jpg)
Revisando EscopoExemplo
• Quais escopos temos no exemplo abaixo?
class Casa
{public Porta portaCasa = new Porta( );public Janela janelaCasa = new Janela( );
static void Main( ){
Casa cas = new Casa( );cas.portaCasa.Abrir( );cas.janelaCasa.Abrir( );
}}
![Page 301: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/301.jpg)
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
![Page 302: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/302.jpg)
Declarando namespacesnamespace Empresa{
namespace Construcao{
class Porta{
public string cor;
public void Abrir( ){
Console.WriteLine( "Abir porta" );}
}}
}
![Page 303: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/303.jpg)
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)
![Page 304: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/304.jpg)
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
![Page 305: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/305.jpg)
usingExemplo
using System;using Empresa.Construcao;
class ExemploCasa{
static void Main( ){
Casa minhaCasa = new Casa( );minhaCasa.janelaCasa.Abrir( );minhaCasa.portaCasa.Abrir( );
}}
![Page 306: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/306.jpg)
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
![Page 307: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/307.jpg)
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
![Page 308: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/308.jpg)
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
![Page 309: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/309.jpg)
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 );}
}
![Page 310: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/310.jpg)
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
![Page 311: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/311.jpg)
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
![Page 312: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/312.jpg)
Operadores, delegações e eventos
![Page 313: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/313.jpg)
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)
![Page 314: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/314.jpg)
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 *, ->, [ ], &
![Page 315: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/315.jpg)
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
![Page 316: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/316.jpg)
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
![Page 317: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/317.jpg)
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( ) );
}
![Page 318: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/318.jpg)
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
![Page 319: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/319.jpg)
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 );
}
![Page 320: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/320.jpg)
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
![Page 321: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/321.jpg)
Sobrecarga de OperadoresExemplo
public static decimal operator+( ContaCorrente conta1, decimal valor )
{return ( conta1.Saldo( ) + valor );
}
![Page 322: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/322.jpg)
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
![Page 323: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/323.jpg)
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( );
![Page 324: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/324.jpg)
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
![Page 325: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/325.jpg)
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( );
![Page 326: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/326.jpg)
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
![Page 327: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/327.jpg)
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
![Page 328: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/328.jpg)
Propriedades e Indexadores
![Page 329: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/329.jpg)
Objetivos
• Utilizando propriedades• Utilizando indexadores
![Page 330: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/330.jpg)
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
![Page 331: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/331.jpg)
Propriedades
• Sintaxe:
[modificador acesso] [tipo de dado] [nome propriedade]{
get{
[código]return [nome do campo];
}set{
[código][nome do campo] = value;
}}
![Page 332: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/332.jpg)
PropriedadesExemplo
private string email;
public string EMail{
get{
return ( this.email );}set{
this.email = value;}
}
![Page 333: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/333.jpg)
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
![Page 334: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/334.jpg)
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)
![Page 335: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/335.jpg)
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;}
}}
![Page 336: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/336.jpg)
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 );}
}
![Page 337: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/337.jpg)
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
![Page 338: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/338.jpg)
Atributos
![Page 339: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/339.jpg)
Objetivos
• Entender o que são atributos
![Page 340: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/340.jpg)
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
![Page 341: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/341.jpg)
Conditional
using System;using System.Diagnostics;
class TestConditional{
static void Main( ){
TestConditional tc = new TestConditional( );
tc.TouchOnly( );}
[Conditional("TOUCH")]public void TouchOnly( ){
Console.WriteLine( "Só serei mostrado com a constante TOUCH definida." );}
}
![Page 342: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/342.jpg)
Atributos
• [Serializable]
• [NonSerializable]
• [WebMethod]
• [STAThread]
• [Obsolete]
![Page 343: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/343.jpg)
Alguma Promessa Pendente???
![Page 344: Curso de C#](https://reader036.vdocuments.pub/reader036/viewer/2022062309/568149ee550346895db71ec2/html5/thumbnails/344.jpg)
FIM