Introducao ao C#

(sc)2 Introdução a
1º Simpósio de Linguagem
C Sharp
Computação do

Sul Capixaba ECMA, Microsoft, C# 3.0,if,
Types, switch, Reference,
value, LINQ, delegate, ?:,
Boxing, bool, Overload,
“Todas as áreas POO, static, Genereics,
Nullable, object, void,
computando novas idéias”
struct, where, return,
dynamic, interface, partial,
Extension, string, as, is,
Anders, get, property,
sealed, internal, foreach,
ref, out, this, Constructor

andre.lopes@studentpartners.com.br

Introdução a linguagem C#

Tópicos
 Histórico
 Características
 Tipos
 Operadores
 Expressões
 Orientação a Objeto
 Código não gerenciado
 C# 2.0
 C# 3.0
 C# 4.0



Um pouco de história
 Idealizada por Anders Hejlsberg

 Anunciada em Junho de 2000

 Não-Proprietária

 Padronizada pela ECMA334

 Desenvolvida para a .NET FCL

 Nome (C#)



Características
 Orientada a objetos

 Influenciada pelo C++ e Visual Basic

 Independente de plataforma e Sistema Operacional

 Fortemente tipada

 Tudo é um objeto

 Permite código não gerenciado



Exemplo



Tipos
 Tipos de Valor
int i = 2011;

2011

 Tipos de Referência
string s = ‚C Sharp‛;
“C Sharp”;

 Aceita null



Tipos
 Tipos de referência
string -> string str = ‚Microsoft‛;
object -> object obj = ‚My object‛;

 Tipos de Valor
Inteiro
int i = -1024; (-231 até 231)
uint u = 1024; (0 até 232)

Longo
long l = -100000; (-263 até 263)
ulong u = 100000; (0 até 264)



Tipos
 Tipos de Valor
Byte
byte b = 200; (0 a 255)
sbyte sb = 120; (-128 a 127)

Char
char c = ‘A’;

Ponto Flutuante
float f = 3.4F; (-3.4×1038 a 3.4×1038)
decimal d = 1.57M; (-7.9x1028 a 7.9x1028)
double l = 1E06; (±5.0×10−324 a ±1.7×10308)



Tipos
 Tipos de Valor
Booleano
bool b = true;

Enumerador
enum tipoPessoa {Fisica = 1, Juridica = 2};
Struct
struct Pessoa
{
string nome;
int idade;
tipoPessoa tipo;
};



Tipos
 Arrays
 Reference Type

int[] iArray = new int[1024];
int i = 2048;
iArray = new int[i];

string[,] NumerosIdiomas = new string[9, 2];
NumerosIdiomas[0, 0] = ‚Zero‛;
NumerosIdiomas[0, 1] = ‚Zero‛;
NumerosIdiomas[1, 0] = ‚Um‛;
NumerosIdiomas[1, 1] = ‚One‛;



Tipos
 O tipo string

 Imutável
Memória
string s = ‚C‛; “C”
s += ‚#‛; “C#”
s = ‚C++‛; “C++”

 Formato
 string.Format(‚Os valores são {0} e {1}‛,
valor1, valor2);



Tipos
 O tipo string

 Formato
 string.Format(‚{0:c}‛, 10); //R$ 10,00

 string.Format(‚{0:c}‛, 10.2365); //R$ 10,23

 string.Format(‚{0:n}‛, 10); //10,00

 string.Format(‚{0:n}‛, 10.2365); //10,23

 string.Format(‚{0:00.00}‛, 1.2); //01.20

 string.Format(‚{0:#.##}‛, 1.2); //1.20



Tipos
 O tipo string

string str = ‚ECMA334‛;
int i = str.Length; //i = 7
bool b = str.Contains(‚3‛); //b = true
char c = str[3]; //c = ‘A’
i = str.IndexOf(‚33‛); //i = 4
str = str.Replace(‚ECMA‛,‛C#‛); //str = C#334
str = str.Remove(2); //str = C#
str = str.ToLower(); //str = c#



Tipos
 O tipo double para cálculos científicos

string s = (1.0 / 0).ToString(); // +Infinito
s = (-1.0 / 0).ToString(); // -Infinito
s = (0.0 / 0).ToString(); // NaN(Não é um número)

s = (1.0M / 0).ToString(); // Erro, decimal não
//pode ser divido por 0
bool b = (0.0 / 0) == double.NaN; //b = false
b = double.IsNan((0.0 / 0)); //b = true
b = (1.0 / 0) == double.PositiveInfinity //b = false
b = double.IsInfinity((1.0 / 0)) //b = true



Delegates
 Ponteiro para funções
delegate double FazCalculo(double v1, double v2);

double Multiplica(double v1, double v2)
{
return v1*v2;
}

double Subtrai(double v1, double v2)
{
return v1 - v2;
}



Delegates

void calcula(double v1, double v2)
{
FazCalculo calculo = Multiplica;
double resultado = 0.0;
resultado = calculo(1.1, 2.0);
//resultado = 2.2;

calculo = Subtrai;

resultado = calculo (2.0,1.0);
//resultado = 1.0;
}



Conversão entre tipos
 Boxing
int i = (int)1.6; //i = 1
object o = 9.5; //o = 9.5

 Unboxing
double d = (double)o; //d = 9.5

 Operador as
object o = ‚abc‛ //o = ‚abc‛
string s = o as string; //s = ‚abc‛
o = 123; //o = 123
s = o as string; //s = null



Operadores Aritméticos
 Adição
int i = 0; //i = 0
i = 5 + 8; //i = 13
i += 5; //i = 18
i++; //i = 19
++i; //i = 20

 Subtração
int j = 0; //j = 0
j = 3 - 5; //j = -2
j -= 5; //j = -7
j--; //j = -8
--j //j = -9



Operadores Aritméticos
 Multiplicação
double d = 2.6 * 1; //d = 2.6
d *= 2; //d = 5.2

 Divisão
double d = 1.6 / 1; //d = 1.6
d /= 2; //d = 0.8
j -= 5; //j = -7

 Resto
decimal d = 1.2M % 1; //d = 0.2
d %= 1; //d = 0.2



Operadores Condicionais
 ==

 !=

 is
if(i is int)
else if(i is double)
else if(i is object)
 > <

 >= <=

 &&

 ||
 ?:
bool IgualADez = (i == 10 ? true : false);



Expressões
 if

if(expressão1)
{
//Código
}
else if(expressão2)
{
//Código
}
else
{
//Código
}



Expressões
 switch
switch(variável)
{
case valor1:
{
//código
break;
}
case valor2:
{
//código
return null;
}
default:
{
//código
break;
}

}



Expressões
 while
while(condição)
{
//código
}

 do
do
{
//código
} while(condição);



Expressões
 for
for(int i = 0; i > 150; i++)
{
//código
if(i < 30)
{
continue;
}
break;
}

 foreach
foreach(int i in intArray)
{
//código
}



Namespaces
 Forma de organização de classes

 Toda classe pertencer a um, e somente um, namespace
using Entidades;
namespace Entidades namespace Funcoes
{ {
public class Pessoa() public class CriaPessoa()
{ {
Pessoa() Pessoa()
{ {
} }
}
public Pessoa Cria()
public class Carro() {
{ return
Carro() new Pessoa();
{ }
} }
}
} }


Orientação a Objeto
 Classe
class Exemplo
{
Exemplo()
{
}

~Exemplo()
{
}
}

 Objeto
Exemplo ex = new Exemplo();



 Herança Simples

 Multiplos Contratos

interface IPessoa
{
string Nome;
int Idade;
}

interface ICliente
{
double Limite;
}



class BaseClass
{
BaseClass()
{
}
}
class Cliente : BaseClass, IPessoa,
ICliente
{
Cliente()
{
base.BaseClass();
}
string Nome
int idade;
double Limite
}



 Classe Abstrata

abstract class ClasseBase
{

}

 Classes que não podem ser herdadas

sealed class ClasseFinal : ClasseBase
{
public ClasseFinal()
{
}
}



 Polimorfismo

{
public virtual string Nome()
{
return ‚ClasseBase‛;
}
}
{
{
}

public override string Nome()
{
return ‚ClasseFinal‛;
}
}



 O modificador new

{
public string Nome()
{
return ‚ClasseBase‛;
}
}
{
{
}

public new string Nome()
{
return ‚‛;
}
}



 Sobrecarga (Overloading)
public class Pessoa
{
public Pessoa() { }

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

public Pessoa(string pNome, int pIdade):this(pNome){this.idade = pIdade;}

private string nome;
public string Nome
{
get{return nome;}
set{nome = value;}
}

private int idade;
public int idade;
{
get{return idade;}
set{idade = value;}
}
}



 Sobrecarga de Operadores

class Vetor
{
int x, y;
public Vetor(int x, int y)
{
this.x = x;
this.y = y;
}
public static Vetor operator +(Vetor a, Vetor b)
{
return new Vetor(a.x + b.x, a.y + b.y);
}
}



 Sobrecarga de Operadores

 Podem ser sobrecarregados
+ -
! ==
* /
& %
^ >
< >=
<= ++
-- true
false

 Não podem ser sobrecarregados
sizeof new
is as
typeof &&
||


 Métodos, funções e propriedades
class Cliente
{
public Cliente()
{
}

private decimal salario;
public decimal Salario
{
get{return salario;}
set
{
if(value >= 0)
salario = value;
}
}

public decimal Limite()
{
return salario * 0.5;
}
}



 Modificadores de acesso
private
public
internal
protected
protected internal



Passagem de parâmetros
 Value Types
Valor
Prefixo ref
Prefixo out

 Reference Types
Referencia
Cuidado ao modificar membros de classe




internal void Incrementa(int i)
{
i++;
}

internal void IncrementaOut(out int i)
{
i = 0;
i++;
}

internal void IncrementaRef(ref int i)
{
i++;
}




internal void TestaIncremento()
{
int i;
Incrementa(i); //Erro Compilação
IncrementaRef(ref i); //Erro Compilação
IncrementaOut(out i) //i = 1;
i = 10;
Incrementa(i); //i = 10
IncrementaRef(ref i); //i = 11
}



public class Pessoa
{
public Pessoa()
{

}

public string PNome { get; set; }
public Carro PCarro { get; set; }
}

public class Carro
{
public Carro()
{

}
public string Nome { get; set; }
}



public void AlteraNome(Pessoa P)
{
P.PNome += ‚ Gates‛;
}

public void CriaCarro(Carro C)
{
C = new Carro();
C.Nome = ‚Vectra‛;
}

public void CriaPessoa()
{
Pessoa pessoa = new Pessoa();
pessoa.PNome = ‚Willian‛;
AlteraNome(pessoa); //pessoa.PNome = ‚Willian Gates‛
AlteraCarro(pessoa.PCarro); //pessoa.PCarro = null
}



Membros estáticos e instanciáveis
 Estático (static)
Classes globais
Evitar o uso
Não acessa membros não estáticos

 Não estático
Padrão
Acessam membros estáticos



Constantes VS Somente leitura
 Constante (const)
Estático
Avaliado em tempo de compilação

 Somente Leitura (readonly)
Não é estático
Avaliado em Runtime
Pode ser modificado no construtor da classe



Constantes VS Somente leitura
 Constante
public class ExeConst
{
public const string ClassName = ‚ExeConst‛;
public const double PISen = Math.Sin(Math.PI); //Erro

public ExeConst()
{
}
}

 Somente Leitura
public class ExeReadOnly
{
public const string ClassName = string.Empty;
public const double PISen = Math.Sin(Math.PI);

public ExeConst()
{
ClassName = ‚ExeReadOnly‛;
}
}


Unsafe Code
 Código não gerenciado

 Ponteiros

 Por que usar ?
 Aplicações em tempo real
 Funções externas
 Programas Monitoradores



Unsafe Code
 Vantagens
 Performance e Flexibilidade
 Compatibilidade
 Acesso direto a memória

 Desvantagens
 Sintaxe mais complexa
 Perigoso



Unsafe Code
 O método tem que ser unsafe ou ter um bloco demarcado com a
palavra unsafe

class unsafeExemplo
{
unsafe void VerificaEnderecoMemoria()
{
int* ptr;
int vlr = 1024; //vlr = 1024

ptr = &vlr; //*ptr = 1024
string s = ptr->ToString();// s = ‚1024‛

int ptrVlr = (*ptr); //ptrVlr = 1024
(*ptr) = 2048; //vlr = 2048; ptrVlr = 1024
}
}



Unsafe Code
class unsafeExemplo
{
void VerificaEnderecoMemoria()
{
unsafe
{
int* ptr;
int vlr = 1024; //vlr = 1024

ptr = &vlr; //ptr = 0x05cbe910
string s = ptr->ToString();// s = ‚1024‛

int ptrVlr = (*ptr); //ptrVlr = 1024
(*ptr) = 2048; //vlr = 2048;
//ptrVlr = 1024
}
}
}



C Sharp 2.0
 Generics

 Anonymous Methods

 Partial Types

 Nullable types

 Modificadores de acesso em propriedades



Generics
 Oque são ?



Sem Generics
class Pilha
{
object[] Items;
int index;
public Pilha()
{
Items = new object[100];
index = -1;
}

public void Empilha(object o)
{
Items[++i] = o;
}

public object Desempilha()
{
return Items[i--];
}
}



Sem Generics
void PilhaSemGenerics()
{
Pilha p = new Pilha();
p.Empilha(1);
p.Empilha(2);

int v1 = (int)p.Desempilha(); //Unboxing necessário
int v2 = (int)p.Desempilha(); //Unboxing necessário
}



Com Generics
class Pilha<T> where T : struct
{
T [] Items;
int index;
public Pilha()
{
Items = new T[100];
index = -1;
}

public void Empilha(T o)
{
Items[++index] = o;
}

public T Desempilha()
{
return Items[index--];
}
}



Com Generics
void PilhaComGenerics()
{
Pilha<int> pInt = new Pilha()<int>;
pInt.Empilha(1);
pInt.Empilha(2);

int v1 = pInt.Desempilha(); //Unboxing desnecessário
int v2 = pInt.Desempilha(); //Unboxing desnecessário

Pilha<decimal> pDecimal = new Pilha()<decimal>;
pDecimal.Empilha(1.0M);
pDecimal.Empilha(2.0M);

decimal v1 = pDecimal.Desempilha();//Unboxing desnecessário
decimal v2 = pDecimal.Desempilha();//Unboxing desnecessário

}



Métodos Anônimos
 Usado onde delegates são esperados

 Métodos “in line”
 Acesso a variáveis locais
 “Métodos dentro de métodos”



Sem Métodos Anônimos
double Multiplica(double v1, double v2)
{
return v1*v2;
}
double Subtrai(double v1, double v2)
{
return v1 - v2;
}

{
FazCalculo calculo = Multiplica;
resultado = calculo(1.1, 2.0); //resultado = 2.2;

calculo = Subtrai;

resultado = calculo (2.0,1.0); //resultado = 1.0;
}


Com Métodos Anônimos
{
FazCalculo calculo = delegate(double v1, double v2)
{
return v1 * v2;
};
resultado = calculo(1.1, 2.0); //resultado = 2.2;

calculo = delegate(double v1, double v2)
{
return (v1 - v2) * resultado;
};

resultado = calculo (2.0,1.0); //resultado = 2.2;
}



Partial Types
 Permite dividir uma mesma entidade em
arquivos diferentes
 Classes
 Structs
 Interfaces



Sem Partial Types
public class Cliente
{
private Compra[] compras;
private int index;
public Cliente()
{
compras = new Compra[100];
index = 0;
}

public void RealizaCompra(Compra compra)
{
compras[index++] = compra;
}

public bool RealizouCompra(){return index > 0;}
}



Com Partial Types
public partial class Cliente
{
private Compra[] compras;
int index;
public Cliente()
{
compras = new Compra[100];
index = 0;
}
}
public partial class Cliente
{
public void RealizaCompra(Compra compra)
{
compras[index ++] = compra;
}

public bool RealizouCompra(){return index > 0;}
}


Nullable types
 Values Types
 Valor null

int? i;
i = null;
i = 1;
int j = i; //Erro
int j = i.Value; //j= 1;



Modificadores de acesso em propriedades

private string nome;
public string Nome
{
private set
{ private int idade;
nome = value; public int Idade
} {
public get internal set
{ {
return nome; idade = value;
} }
} public get
{
return idade;
}
}



C Sharp 3.0
 Tipos Implícitos (Implicitly typed local variables )
 Métodos de Extensão (Extension Methods)

 Tipos Anônimos (Anonymous types)

 Linq

 Inicializadores de Objetos (Object initializers)



Tipo Implícitos
var i = 5;

var s = "Hello";
i = s.Length;

var d = 1.0;

var numbers = new int[] {1, 2, 3};
i = numbers[1];

var pessoa = new Pessoa();
Pessoa.Nome = ‚Anders‛;



Métodos de Extensão

public static int ConverterParaInteiro(this double dbl)
{
return (int)dbl;
}

double dbl = 1.57;
int i = (int)dbl; //i = 1;
i = dbl.ConverterParaInteiro(); //i = 1;



Tipos Anônimos

var p1 = new { Nome = ‚Vectra", Preco = 120000.0 };
var p2 = new { Nome = ‚Gol", Preco = 45000.0 };
p1 = p2;
p1.Nome = ‚Corsa‛;

var contatos = new[] {
new { Nome = "Cris Brown",
Telefones = new[] { "206-555-0101",
"425-882-8080" }
},
new { Nome = "Bobs Burgers",
Telefones = new[] { "650-555-0199" }
}
};



Linq
Pessoa ObtemPessoa(Pessoa[] Pessoas, string Nome)
{
var pessoa = (from p in Pessoas
where p.Nome = Nome
select p).ToArray();
if(pessoa.Length == 0)
return null;
else
return pessoa[0] as Pessoa;
}

Pessoa[] pessoas = new Pessoa[10];
CarregaPessoas(pessoas);

var pessoasEmOrdem = from p in pessoas
orderby p.Nome
select p;



Inicializadores de Objetos
public class Pessoa
{
public Pessoa()
{

}

public string PNome { get; set; }
public int PIdade { get; set; }
}

Pessoa p1 = new Pessoa(){PNome = ‚Ana‛, PIdade = 17 };

Pessoa p2 = new Pessoa(){PNome = ‚Caio‛, PIdade = 27};



C Sharp 4.0
 Tipos dinâmicos

 Parâmetros Nomeados e Opcionais



Tipos dinâmicos
 Um objeto melhorado
 Operações verificadas em runtime

object o = 0.0;
o = ((double)o) + 2.0; //o = 2.0

o = ‛C Sharp 2.0‛;
int i = (d as string).Length;

o = new Pessoa();
(o as Pessoa).Nome = ‚Objeto‛;



Tipos dinâmicos

var v = 1.0;
v += 2.0

v = ‚C Sharp 4.0‛; //Erro, não pode converter
//string para double
int i = v.Length; //Erro

v = new Pessoa(); //Erro
v.Nome = ‚Tipo dinâmico‛; //Erro



Tipos dinâmicos
dynamic d = 1.0;
d += 2.0

d = ‚C Sharp 4.0‛;
int i = d.Length;

d = new Pessoa();
d.Nome = ‚Tipo dinâmico‛;



Tipos dinâmicos
public dynamic exampleMethod(dynamic d)
{
// A dynamic local variable.
dynamic local = "Local variable";
int two = 2;
if (d is int)
{
return local;
}
else
{
return two;
}
}



Parâmetros Nomeados e Opcionais
 Finalmente
 “Sobrecarga”

void VendeItem(ItemEntidade Item , double Quantidade)
{
{...}
}
void VendeItem(ItemEntidade Item)
{
VendeItem(Item, 1.0);
}
void VendeItem()
{
ItemEntidade Item = new ItemEntidade();
VendeItem(Item); //Vende uma unidade do item
VendeItem(Item, 1.0); //Vende uma unidade do item
VendeItem(Item, 2.0); //Vende duas unidades do item
}



void VendeItem(ItemEntidade Item , double Quantidade = 1.0)
{
{...}
}

void VendeItem()
{
ItemEntidade Item = new ItemEntidade();
VendeItem(Item); //Vende uma unidade do item
VendeItem(Item, 1.0); //Vende uma unidade do item
VendeItem(Item, 2.0); //Vende duas unidades do item
}



public void VendeItemIF(string Descricao, string UF,
double Preco, double Quantidade = 1.0,
double Desconto = 0.0, string Unidade = "UN")
{
{...}
}

VendeItemIF("Visual Studio", "ES", 1200d);

VendeItemIF("Visual Studio", "ES", 1200d,Unidade:‚CX");



The End



Bibliografia
 C# Language Specification 1.0


Introducao ao C#

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Introducao ao C#

Introducao ao C#