introducao ao c#

Introdução a Linguagem

C Sharp

[email protected]

ECMA, Microsoft, C# 3.0,if,

Types, switch, Reference,

value, LINQ, delegate, ?:,

Boxing, bool, Overload,

POO, static, Genereics,

Nullable, object, void, struct, where, return,

dynamic, interface, partial,

Extension, string, as, is,

Anders, get, property,

sealed, internal, foreach,

ref, out, this, Constructor

(sc)2

1º Simpósio de Computação do Sul Capixaba

“Todas as áreas

computando novas idéias”

[email protected]

Introdução a linguagem C#

H i s t ó r i c o

C a r a c t e r í s t i c a s

T i p o s

O p e r a d o r e s

E x p r e s s õ e s

O r i e n t a ç ã o a O b j e t o

C ó d i g o n ã o g e r e n c i a d o

C # 2 . 0

C # 3 . 0

C # 4 . 0

Tópicos


[email protected]

Idealizada por Anders Hejlsberg

Um pouco de história

Anunciada em Junho de 2000

Desenvolvida para a .NET FCL

Não-Proprietária

Padronizada pela ECMA334

Nome (C#)


[email protected]

Características

Orientada a objetos

Influenciada pelo C++ e Visual Basic

Tudo é um objeto

Independente de plataforma e Sistema Operacional

Fortemente tipada

Permite código não gerenciado


[email protected]

Exemplo


[email protected]

Tipos

Tipos de Valor

Tipos de Referência

int i = 2011;

2011

string s = ‚C Sharp‛;

“C Sharp”;

Aceita null


[email protected]

Tipos

Tipos de referência

Tipos de Valor

string -> string str = ‚Microsoft‛;

object -> object obj = ‚My object‛;

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)


[email protected]

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)


[email protected]

Tipos

Tipos de Valor

Booleano

bool b = true;

Enumerador

enum tipoPessoa {Fisica = 1, Juridica = 2};

Struct

struct Pessoa { string nome; int idade; tipoPessoa tipo; };


[email protected]

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‛;


[email protected]

Tipos

O tipo string

Imutável

string s = ‚C‛;

s += ‚#‛;

s = ‚C++‛;

Memória

“C”

“C#”

“C++”

Formato

string.Format(‚Os valores são {0} e {1}‛,

valor1, valor2);


[email protected]

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


[email protected]

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#


[email protected]

Tipos

O tipo double para cálculos científicos

string s = (1.0 / 0).ToString();

s = (-1.0 / 0).ToString();

s = (0.0 / 0).ToString();

s = (1.0M / 0).ToString();

bool b = (0.0 / 0) == double.NaN;

b = double.IsNan((0.0 / 0));

b = (1.0 / 0) == double.PositiveInfinity

b = double.IsInfinity((1.0 / 0))

// +Infinito

// -Infinito

// NaN(Não é um número)

// Erro, decimal não //pode ser divido por 0

//b = false

//b = true

//b = true

//b = false


[email protected]

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; }


[email protected]

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; }


[email protected]

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


[email protected]

Adição

Operadores Aritméticos

int i = 0; //i = 0

i = 5 + 8; //i = 13

i += 5; //i = 18

Subtração

i++; //i = 19

++i; //i = 20

int j = 0; //j = 0

j = 3 - 5; //j = -2

j -= 5; //j = -7

j--; //j = -8

--j //j = -9


[email protected]

Multiplicação

Operadores Aritméticos

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


[email protected]

Operadores Condicionais

==

!=

>= <=

is

> <

&&

||

?:

if(i is int) else if(i is double) else if(i is object)

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


[email protected]

Expressões

if

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


[email protected]

Expressões

switch

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


[email protected]

Expressões

while

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

do

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


[email protected]

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 }


[email protected]

Namespaces

Forma de organização de classes

Toda classe pertencer a um, e somente um, namespace

namespace Entidades { public class Pessoa() { Pessoa() { } } public class Carro() { Carro() { } } }

using Entidades; namespace Funcoes { public class CriaPessoa() { Pessoa() { } public Pessoa Cria() { return new Pessoa(); } } }


[email protected]

Orientação a Objeto

Classe

class Exemplo { Exemplo() { } ~Exemplo() {

} }

Objeto

Exemplo ex = new Exemplo();


[email protected]


Herança Simples

Multiplos Contratos

interface IPessoa { string Nome; int Idade; }

interface ICliente { double Limite; }


[email protected]


class BaseClass { BaseClass() { } }

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


[email protected]


Classe Abstrata

abstract class ClasseBase { }

Classes que não podem ser herdadas

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


[email protected]


Polimorfismo

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

sealed class ClasseFinal : ClasseBase { public ClasseFinal() { } public override string Nome() { return ‚ClasseFinal‛; } }


[email protected]


O modificador new

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

sealed class ClasseFinal : ClasseBase { public ClasseFinal() { } public new string Nome() { return ‚‛; } }


[email protected]


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;} } }


[email protected]


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); } }


[email protected]


Sobrecarga de Operadores

Podem ser sobrecarregados

+ - ! == * / & % ^ > < >= <= ++ -- true false

Não podem ser sobrecarregados

sizeof new is as typeof && ||


[email protected]


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; } }


[email protected]


Modificadores de acesso

private

public

internal

protected

protected internal


[email protected]

Passagem de parâmetros

Value Types

Valor

Prefixo ref

Prefixo out

Reference Types

Referencia

Cuidado ao modificar membros de classe


[email protected]


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

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

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


[email protected]


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 }


[email protected]


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; } }


[email protected]


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

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

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


[email protected]

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


[email protected]

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


[email protected]

Constantes VS Somente leitura Constante

Somente Leitura

public class ExeConst { public const string ClassName = ‚ExeConst‛; public const double PISen = Math.Sin(Math.PI); //Erro public ExeConst() { } }

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


[email protected]

Unsafe Code

Vantagens

Desvantagens

Performance e Flexibilidade

Compatibilidade

Acesso direto a memória

Sintaxe mais complexa

Perigoso


[email protected]

Unsafe Code

O método tem que ser unsafe ou ter um bloco demarcado com a

palavra unsafe


[email protected]

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


[email protected]

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


[email protected]

Anonymous Methods

Partial Types

Nullable types

Modificadores de acesso em propriedades

Generics


[email protected]

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--]; } }


[email protected]

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 }


[email protected]

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--]; } }


[email protected]

Com Generics


[email protected]

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


[email protected]

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 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;

}

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;

}


[email protected]

Com Métodos Anônimos


[email protected]

delegate double FazCalculo(double v1, double v2);

void calcula(double v1, double v2)

{

FazCalculo calculo = delegate(double v1, double v2)

{

return v1 * v2;

};

double resultado = 0.0;

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


[email protected]

Permite dividir uma mesma entidade em arquivos diferentes

Classes

Structs

Interfaces


[email protected]

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;} }


[email protected]

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


[email protected]

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


[email protected]

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

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

C Sharp 3.0

Tipos Implícitos (Implicitly typed local variables )


[email protected]

Métodos de Extensão (Extension Methods)

Tipos Anônimos (Anonymous types)

Linq

Inicializadores de Objetos (Object initializers)

Tipo Implícitos


[email protected]

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


[email protected]

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


[email protected]

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


[email protected]

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


[email protected]

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


[email protected]

Parâmetros Nomeados e Opcionais

Tipos dinâmicos


[email protected]

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


[email protected]

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


[email protected]

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


[email protected]

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; } }



[email protected]

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 }



[email protected]

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 }



[email protected]

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


[email protected]

Bibliografia

C# Language Specification 1.0






[email protected]

introducao ao c#

Technology