C#NET

ESTCB - IPCBDepartamento de Engenharia Informática

Projecto de Sistemas Industriais

C#.NET

ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 2

Sumário – C#.NET

Variáveis

Documentação XML

C# Preprocessor Directives

Operadores

Estruturas de Decisão

Estruturas de Ciclo

Erros e Excepções

Classes e Objectos


C# - Orientada a Objectos

Apresentada como primeira linguagem “Orientada por componentes” da família

C/C++

Considerações de evolução de versões pensadas na linguagem

Componentes auto-descritivos:

Metadados, incluindo atributos definidos pelo utilizador, consultados em tempo de

execução através de reflexão;

Documentação integrada em XML;

Suporte para propriedades, métodos e eventos

Programação simples:

Pode ser integrada em páginas ASP


C# - Orientada a Objectos

Tudo é um objecto

Herança simples de implementação e herança múltipla de interface (como em

java)

Polimorfismo a la carte com métodos virtuais (como em C++)

Membros estáticos (partilhados) e de instância (como em c++ e Java)

Vários tipos de membros:

Campos, métodos, construtores e destrutores;

Propriedades, indexadores, eventos e operadores (como em c++)

Não tem templates


C# - Robustez

Gestão automática de mémória (garbage collection):

Elimina problemas com fugas de memória e apontadores inválidos

Mas quem quiser pode trabalhar directamente com apontadores

Excepções

Melhor tratamento de erros

Segurança de tipos (type-safety)

Elimina variáveis não inicializadas, coerção insegura de tipos, etc.


C# - Preservar Investimentos

Semelhanças com C++ e Java

Espaços de nomes;

Nenhum sacrifício necessário

Interoperabilidade

Cada vez mais importante

C# fala com XML, SOAP, COM, DLLs, e qualquer linguagem do .NET

FRAMEWORK

Milhões de linhas de código C# no .NET

Pequena curva de aprendizagem

Melhor produtividade


C# - Tipos de Dados

O C# é uma linguagem altamente “Tipada”, é necessário indicar qual o tipo de

dados de cada objecto criado

O compilador ajuda a prevenir erros forçando que unicamente a atribuição dos

dados correctos ao objecto em questão.

O tipo de um objecto indica ao compilador o tamanho do mesmo e as suas

capacidades:

1 int indica um objecto de 4 bytes,

Se for um button, pode ser pressionado, desenhado, etc.

Tal como o C++ e o Java os tipos de dados dividem-se em dois conjuntos,

intrínsecos e os definidos pelo programador.

No entanto o C# ainda divide os conjuntos em duas outras categorias, Tipos

Valor e Tipos Referência. A principal diferença resida na forma como são

armazenados na memória


C# - Tipos de Dados

Tipos Valor

Variáveis contêm directamente dados/instâncias

Não podem ser null

Comparação e atribuição operam com os próprios valores (em C#)

Manipulação eficiente porque podem ser alocados na stack

Tipos Referência

Variáveis contêm referências para objectos/instâncias (no heap)

Podem ser null

Comparação e atribuição operam com referências

Gestão automática de memória (gabage collection do CLR)


C# - Tipos de Dados

Tipos Valor

Primitivos int i;

Enumerações enum State {On, OFF}

Estruturas struct Point {int x,y;}

Tipos Referência

Arrays string[] a = new string[10];

Classes class Foo:Bar,IFoo {…}

Interfaces interfaceIFoo:IBar {…}

Delegados delegate double MathFunc (double x);


C# - Tipos de Dados

Até 28 dígitos, normalmente utilizado em aplicações financeirasdecimal16System.Decimal

True ou Falsebool1System.Boolean

Virgula flutuante de dupla precisãoDouble8System.Double

Numeros de virgula FlutuanteFloat4System.Single

Caractereschar2System.Char

64 bits sem sinal (0 até 0xFFFFFFFFFFFFFFFF)ulong8System.UInt64

64 bits com sinal (-9,223,372,036,854,775,808 até 9,223,372,036,854,775,807)

long8System.Int64

32 bits sem sinal (0 até 4,294,967,295)uint4System.UInt32

32 bits com sinal (-2,147,483,648 até 2,147,483,648)int4System.Int32

16 bits sem sinal (0 até 65,535)ushort2System.UInt16

16 bits com sinal (-32,768 até 32767)short2System.Int16

8bits sem sinal (0 até 255)byte1System.Byte

8 bits com sinal (-128 até 127)sbyte1System.SByte

StringstringSystem.String

Classe base para todos os tipos CTSobjectSystem.Object

Descrição.NET tipoTamanhoCTS Type Name


Stack e Heap

Uma Stack consiste numa estrutura para armazenar dados utilizando o conceito

LIFO (last-in-First-out). A Stack refere-se a uma área de memória suportada

pelo processador, na qual as variáveis locais são armazenadas.

Na linguagem C#, os Tipo Valor (por exemplo inteiros) são alocados na Stack.

Tipos Referência (por exemplo objectos) são armazenados na Heap. Quando um

objecto é armazenado na Heap, o seu endereço é retornado e é atribuído a uma

referência.

O gargabe collector destrói os objectos armazenados na Stack, após a estrutura

desta ter sido eliminada. Tipicamente, uma estrutura de Stack é definida dentro

de uma função. Sendo assim, todos os objectos declarados dentro da função,

serão “marcados” para garbage collection, quando esta terminar a sua

execução.

Os objectos armazenados na Heap, são eliminados pelo garbage collector, após a

sua referência ter sido eliminada.


C# - Variáveis & Constantes

Variáveis

Uma variável é criada através da atribuição de um nome e da declaração do tipo.

Pode ser inicializada quando se declara, e é possível alterar o seu valor em

qualquer momento.

O C# requere atribuição de valores, isto é, uma variável não pode ser usada sem

antes possuir um valor.

Constantes

Uma constante consiste numa variável cujo valor não pode ser modificado.

As constantes podem ser de três tipos, literais, constantes simbólicas e

enumerações (enumerations)

X = 32; Literal

const int FreezingPoint = 32; constante simbólica


C# - Enumerações

Enumerations

As enumerações constituem uma poderosa alternativa às constantes. Uma

enumeração consiste num conjunto de constantes, denominada enumeration

list.

Definição técnica de uma enumeração:

[attributes] [modifiers] enum identifier [:base-type] {enumerator-list};

enum ServingSizes :uint{

Small = 1,Regular = 2,Large = 3

}


C# - Enumerações

class Values{ enum Temperatures: int {

WickedCold =0,FreezingPoint = 32,LightJacketWeather = 60,SwimmingWeather = 72,BoilingPoint = 212,

} static void Main(string[] args) {

System.Console.WriteLine("Freezing point of water: {0}", (int) Temperatures.FreezingPoint);System.Console.WriteLine("Boiling point of water: {0}", (int) Temperatures.BoilingPoint);

System.Console.Read(); }}

É necessário especificar o tipo de dados que se pretende imprimir, caso seja omisso, o valor imprimido consiste no nome da constante.

Todas as enumerations list possuem scope, isto permite possuir constantes com o mesmo nome em enumerations list diferentes.


C# - Preprocessor Directives

As directivas #region - #endregion, são usadas para indicar o inicio e o fim de

um determinado bloco de código.

#region Funções de Testeint x;double d;Currency balance;

#endregion


C# - Documentação XML

A Linguagem C# permite gerar documentação em formato XML automaticamente a

partir de comentários especiais no código.

Esses comentários consistem em linhas únicas, iniciadas por /// (3 barras).

Dentro desses comentários colocam-se tags de XML que permitem gerar a

documentação.



Especifica uma linha como sendo uma linha de código<c>Especifica várias linhas como sendo código<code>Especifica como sendo código exemplo<example>Documenta uma excepção<exception>Inclui comentários de outro ficheiro de documentação<include>Permite inserir uma lista dentro da documentação<list>

Descreve uma propriedade<value>Permite especificar um breve sumário.<sumary>Permite especificar um “ver também”.<seealso>Fornece uma referência cruzada a um outro parâmetro.<see>Documenta o valor de retorno do método.<returns>Adiciona uma descrição a um método.<remarks>Documenta o acesso a um membro.<permission>Especifica que uma palavra é parâmetro do método.<paramref>Especifica 1 parâmetro do método.<param>

DescriçãoTAG



using System;

namespace Math.Exemplo{

/// <summary>/// Classe de Matemática --> Exemplo para PSI/// Fornece um método para adicionar dois inteiros/// </summary>public class Math{

///<sumary>/// O método Add permite adicionar dois inteiros///</sumary>///<returns> O resultado da adicção é (int) </returns>///<paran name="x"> Primeiro inteiro a adicionar </param> ///<paran name="y"> Segundo inteiro a adicionar </param> public int Add(int x, int y){

return x+y;}

}}


C# - Operadores

Um operador consiste num símbolo que obriga a linguagem C# a tomar uma

acção.

Existem diversos tipos de operadores:

Matemáticos,

Incrementos e Decrementos,

Relacionais,

Lógicos em operações condicionais.

Resto da divisão%Divisão/Multiplicação*Subtracção-Adição+

DescriçãoOperador


C# - Operadores

Uma operação comum em programação é a necessidade de somar ou subtrair a

uma variável, ou ainda, modificar o valor de uma variável, e atribui-lo novamente

à mesma variável.

Divide o valor à variável em questão/=Multiplica o valor à variável em questão*=Subtrai o valor à variável em questão-=Soma o valor à variável em questão+=Decrementa um valor--Incrementa um valor++

DescriçãoOperador

myExample = 10;myExample ++; // myExample = 11myExample += 9 // myExample = 20myExample /= 5 // myExample = 4myExample *= 10 // myExample = 40


C# - Operadores

Para complicar ainda mais as coisas, é possível incrementar uma variável e

atribuir esse valor a outra variável.

firstvalue = secondvalue ++;

Coloca-se uma questão com a atribuição anterior: o incremento é para ocorrer

antes ou depois da atribuição?

Sufixosecondvalue = 10;firstvalue = secondvalue++; // firstvalue = 10 // secondvalue = 11

Prefixosecondvalue = 10;firstvalue = ++secondvalue; // firstvalue = 11 // secondvalue = 11


C# - Operadores

Operadores relacionais são utilizados para comparar dois valores, retorna como

resultado um valor booleano.

falsesmallvalue <= bigvaluetruebigvalue <= smallvalue<=Menor ou igual quefalsebigvalue < smallvalue<Menor quefalsesmallvalue >= bigvalue

bigvalue >= smallvaluebigvalue > smallvaluebigvalue != 80bigvalue != 100bigvalue == 80bigvalue == 100

Expressão

>=>

!=

==Operador

falseMaior ou igual quetrueMaior quetruefalseDiferentefalsetrueIgualdade

ResultadoDescrição

Assume-se como valores iniciais para as variáveis:

bigvalue = 100 e smallvalue = 50


C# - Operadores

! (x==3)(x==3) || (y == 7)(x==3) && (y == 7)

Expressão

!||&&

Operador

truenottrueorfalseand

ResultadoDescrição

Assume-se como valores iniciais para as variáveis:

x = 5 e y = 7

typeof

O operador typeof retorna o tipo de dados do objecto em questão.

Isto torna-se útil quando se pretende usar reflexão de forma a obter informção

sobre objecto criados dinamicamente.

Lógicos


C# - OperadoresIS

O operador is permite avaliar se um determinado objecto é compatível com um

determinado tipo.

int i = 10;if (i is object){

Console.WriteLine(“i é um objecto”);}

AS

O operador as é utilizado em conversões explicitas de tipos de dados. Se o tipo

para o qual se pretende converter é compatível com o tipo de dados actual, a

conversão é executada, caso contrário é retornado o valor null.

object o1 = “some string”;object o2 = 5;

string s1 = o1 as string; // s1 = “some string”string s2 = o2 as string; // s2 = null


C# - Operadores

Precedência

= += -= *= /= %= &= |= ^= <<= >>=Atribuição?:Ternário||Boolean OR&&Boolean AND|OR^XOR&AND

== !=Comparação< > <= >= is as

<< >>+ - * / %

+ - ! ~ ++x –-x() . x++ x– new typeof sizeof checked unchecked

Operadores

RelacionaisDeslocamento de bitsAdição/subtracção

Multiplicação/DivisãoUnáriosPrimárioDescrição


C# - Estruturas de Decisão

IF - O mais simples dos comandos condicionais. Teste a condição e executa o

comando, indicando se o resultado é TRUE. Para indicar mais do que um comando

no IF, é necessário utilizar um bloco, demarcado por chavetas.

int i = 4;if (i == 0){

Console.WriteLine(“i é zero”);}else if (i==1){

Console.WriteLine(“i é um”);

}else{

Console.WriteLine(“i é maior que um”);

}



SWITCH - O comando SWITCH funciona como uma sequencia de comandos IF

na mesma expressão. Permite ao programador comparar uma variável com uma

conjunto de valores diferentes, e mediante isso executar um código diferente.

Switch (country){

case “America”:Console.WriteLine(“O país em questão é a América”);break;

case “Inglaterra”:Console.WriteLine(“O país em questão é a Inglaterra”);break;

case “Portugal”:Console.WriteLine(“O país em questão é Portugal”);break;

}



Switch (country){

case “US”:case “UK”:case “AU”:

language = “English”;break;

case “at”:case “de”:

language = “German”;break;

}

Switch (country){

case “America”:Console.WriteLine(“O país em questão é a América”);goto case “Inglaterra”;

case “Inglaterra”:language = “English”;break;

}


C# - Estruturas de Ciclo

WHILE - É o comando de repetição mais simples. Testa uma condição e executa

um comando (ou conjunto de comandos) até a condição ser FALSE.

bool condition = false;while (!condition){

//fica dentro do ciclo até a condição ser trueDoSomeWork();condition = checkCondition();// assume checkCondition() retorna um bool

}



DO…WHILE - Este comando funciona de forma bastante semelhante ao

anterior, diferendo apenas no local onde a condição é testada. Neste comando a

condição só é testada após a execução do bloco de comandos, obrigando à

execução deste pelo menos uma vez.

bool condition;{

// executa pelo menos uma vezDoSomeWork();condition = checkCondition();// assume checkCondition() retorna um bool

} while (condition)



FOR – é a estrutura de controlo mais complexa em PHP. Nesta estrutura é

necessário definir o valor de inicialização, a condição de paragem, e o valor de

incremento.

For (int i = 0; i < 100; i++){

Console.writeLine(i);}

FOREACH – permite interagir com os elementos de um colecção (por agora

considera-se um objecto que possui outros objectos). É importante referir que

dentro desta estrutura não é possível alterar o valor dos elementos da coleção.

foreach (int temp in arrayOfInts){

Console.writeLine(temp);temp++;

}


C# - Excepções

A Linguagem C# trata os erros e condições anormais através de excepções.

Uma excepção consiste num objecto que encapsula informação acerca de uma

ocorrência fora do comum.

É importante distinguir erros, bugs e excepções.

Bug: erro de programação que deverá ser corrigido.

Erro: acontece como consequência da acção do utilizador.

Erros e bugs podem lançar uma excepção.

É impossível prever todas as excepções, mas podem-se tratar de forma a evitar

que o programa colapse.

Quando uma excepção é lançada, a função actual pára, isto é, a função termina

naquele momento, tendo no entanto a oportunidade de tratar a excepção. Se

nenhuma das funções activas tratar a excepção, esta será tratada em última

instância pelo CLR, o qual terminará o programa.


C# - Throw e Catch

throw

Permite indicar a ocorrência de uma condição anormal.

A execução de um programa é automaticamente parada ao ser lançada uma

excepção, enquanto o CRL procura um “handler” que trate a excepção.

Caso não encontre um handler, vai retornando nas funções até encontra algum

que satisfaça a excepção. Caso retorne até ao método main e não encontre um

handler, termina o programa.

catch

Um handler de uma excepção, é denominado por um bloco de catch.

Um catch está associado a um bloco de dados que eventualmente poderá gerar

um erro, esse código encontra-se dentro de um bloco try

Os catchs podem ser gerais, ou especificos.


C# - Excepções - throw

namespace MyThrow{

using System;public class Test{

public static void Main(){

Console.WriteLine("Enter Main...");Test t = new Test();t.Func1();Console.WriteLine("Exit Main...");

}public void Func1(){

Console.WriteLine("Enter Func1...");Func2();Console.WriteLine("Exit Func1...");

}public void Func2(){

Console.WriteLine("Enter Func2...");throw new System.Exception();Console.WriteLine("Exit Func2...");

}}

}

OUTPUT:Enter Main…Enter Func1…Enter Func2…

Exception ocurred: System.Execption: Na exception of type System.Exception was throw.

at MyThrow.Test.Func2();in …exception01.css:line 23

at MyThrow.Test.Func1();in …exception01.css:line 17

at MyThrow.Test.Main();in …exception01.css:line 11


C# - Excepções - catch

namespace MyThrow { using System;

public class Test {

public static void Main() {Console.WriteLine("Enter Main...");Test t = new Test();t.Func1();Console.WriteLine("Exit Main...");

} public void Func1() {

Console.WriteLine("Enter Func1...");Func2();Console.WriteLine("Exit Func1...");

}

public void Func2() {try {

Console.WriteLine("Enter Func2..."); throw new System.Exception(); Console.WriteLine("Exit try Block...");}catch{ Console.WriteLine("Exception caught and handled");}

Console.WriteLine("Exit Func2..."); }}

}

OUTPUT:Enter Main…Enter Func1…Enter Func2…Entering try BlockException caught and handled.Exit Func2…Exit Func1…Exit Main…


C# - Excepções – catch – exemplo 2

namespace MyThrow { using System;

public class Test {

public static void Main() {Console.WriteLine("Enter Main...");Test t = new Test();t.Func1();Console.WriteLine("Exit Main...");

} public void Func1() {

Console.WriteLine("Enter Func1...");try { Console.WriteLine("Enter try Block..."); Func2(); Console.WriteLine("Exit try Block...");}catch{ Console.WriteLine("Exception caught and handled");}Console.WriteLine("Exit Func1...");

}

public void Func2() {Console.WriteLine("Enter Func2...");throw new System.Exception();Console.WriteLine("Exit Func2...");

}}

}


C# - Excepções – catch dedicados

namespace MyDedicatedCatch{

using System;public class DedicatedCatch{


DedicatedCatch t = new DedicatedCatch();t.TestFunc();Console.ReadLine();

}

//do the division if legalpublic double DoDivide(double num1, double num2){

if (num2==0)throw new System.DivideByZeroException();

if (num1==0)throw new System.ArithmeticException();

return num1/num2;}


C# - Excepções – catch dedicados 2

// Try to divide 2 numbers handle possible excaptionspublic void TestFunc(){

try{double a = 5;double b = 0;Console.WriteLine("{0}/{1} = {2}", a,b,DoDivide(a,b));

}//most derived exception type first

catch (System.DivideByZeroException){Console.WriteLine("DivideByZeroException caught!");

}catch (System.ArithmeticException){

Console.WriteLine("ArithmeticException caught!");}//generic exception type lastcatch {

Console.WriteLine("Unknow exception caucht!");}

}}

}


C# - Finally

finally

Nalgumas situações lançar uma excepção pode criar problemas graves. Por

exemplo se existe um ficheiro aberto, ou se existe a pertença de um recurso, é

importante ter oportunidade de fechar o ficheiro, ou limpar o buffer.

Existe sempre a possibilidade de dentro de um bloco catch resolver o problema,

mas isso implicava repetição de código (Exemplo: fechar o ficheiro dentro do

bloco try, e precaver fechando também dentro do bloco catch)

O bloco finally garante a execução de código apesar da ocorrência de uma

excepção.

Um bloco finally pode existir sem um bloco catch, mas necessita

obrigatoriamente de um bloco try.

É um erro sair de um bloco finally com break, continue, return ou goto.


C# - Excepções – finally





}

//do the division if legalpublic double DoDivide(double num1, double num2){

if (num2==0)throw new System.DivideByZeroException();

if (num1==0)throw new System.ArithmeticException();

return num1/num2;}


C# - Excepções – finally 2


try{Console.WriteLine("Open the file here.");double a = 5;double b = 0;Console.WriteLine("{0}/{1} = {2}", a,b,DoDivide(a,b));


catch (System.DivideByZeroException){Console.WriteLine("DivideByZeroException caught!");

}//generic exception type lastcatch {

Console.WriteLine("Unknow exception caucht!");}finally{ Console.WriteLine("Close the file here.");}

}}

}


C# - Objecto Excepção

O objecto System.Exception fornece um número de métodos e propriedades que

permitem obter mais informação sobre a excepção e suas causas.

A propriedade Message permite obter informação acerca da excepção e razão de

ter ocorrido. É read-only.

A propriedade HelpLink fornece um link de ajuda com informação acerca da

excepção. É read/write.

A propriedade StackTrace é read-only e é activada em tempo de execução,

fornece informação acerca do erro ocorrido.


C# - Objecto Excepção





}//do the division if legalpublic double DoDivide(double num1, double num2){

if (num2==0){DivideByZeroException e = new DivideByZeroException();e.HelpLink = "http://www.libertyassociates.com";throw e;

}if (num1==0)

throw new System.ArithmeticException();return num1/num2;

}


C# - Objecto Excepção 2


try {Console.WriteLine("Open the file here.");double a = 5;double b = 0;Console.WriteLine("{0}/{1} = {2}", a,b,DoDivide(a,b));


catch (System.DivideByZeroException e) {Console.WriteLine("\n DivideByZeroException! Msg: {0}", e.Message);Console.WriteLine("\n HelpLink! Msg: {0}", e.HelpLink);Console.WriteLine("\n Here's a stack Trace: {0}", e.StackTrace);

}//generic exception type lastcatch {

Console.WriteLine("Unknow exception caucht!");}finally{ Console.WriteLine("Close the file here.");}

}}

}


C# - Objecto Excepção 3


C# - Classes e Objectos

A diferença entre classe e objecto é a mesma que entre o conceito de cão e um

cão específico. Uma classe cão descreve o cão em si: a cor, a raça, o peso, o

tamanho, etc. Também descreve as acções que o cão pode tomar: comer, ladrar,

andar, dormir. Um cão específico tem características específicas, 10 quilos, olhos

pretos, raça Dálmata.

A grande vantagem da programação orientada aos objectos é o encapsulamento

das características e capacidades de uma entidade num único bloco de código.

Encapsulamento, polimorfismo e herança, são os três pilares base da

programação orientada a objectos.

Ao definir uma nova classe é necessário primeiro declará-la, e so depois declarar

os métodos e os campos.

[attributes] [access-modifiers] class identifier [:base-class]

{class-body}



Um classe é definida dentro de um chavetas: {}

Normalmente o access-modifier utilizado é o public

Public class Tester{

public static int Main(){

//……}

}

Ao declarar uma nova classe, definem-se as propriedades dos objectos das classes

assim como o seu comportamento.

Só existem objectos da classe no fim de instanciados.



access-modifiers determinam quais os métodos da classe (incluindo métodos das

outras classes) que podem visualizar e aceder a variáveis ou métodos desta

classe.

Membros na classe A definidos como protected internal são acessíveis a métodos da classe A e a métodos de classes derivadas desta durante a assemblagem. O conceito é protected OU internal.

protected internal

Membros na classe A definidos como internal são acessíveis unicamente a métodos da classe A durante a assemblagem.

internal

Membros na classe A definidos como protected são acessíveis a métodos da classe A e a métodos de classes derivadas desta.

protected

Membros na classe A definidos como private são acessíveis unicamente a métodos desta classe.

private

Sem restrições, membros definidos como public são visíveis a qualquer método de qualquer classe.

public

RestriçõesAccess-modifiers



É preferível definir as variáveis membro da classe como private. Isto implica que

o acesso aos valores das variáveis seja efectuado somente com recurso a

métodos da classe.

Por defeito a linguagem C# especifica tudo como private, pelo que não é

necessário indicar explicitamente, no entanto é recomendável.

// private variables

private int Year;private int Month;private int Date;private int Hour;private int Minute;private int Second;


C# - Classes - Construtor

O construtor de uma classe consiste no método que é invocado aquando a

instanciação de um objecto.

Pode ser omitido, e deixar o CLR fornecer um construtor por defeito.

O objectivo do construtor é criar um objecto do tipo da classe e colocá-lo num

estado válido.

nullreference

0enum

‘\0’ (null)char

Falsebool

0numeric (int, long, etc)

Valor por defeitoTipo


C# - Classes – Construtor

public class Time{

//private member variablesint Year;int Month;int Date;int Hour;int Minute;int Second;// public acessor Methodspublic void DisplayCurrentTime(){

System.Console.WriteLine("{0}/{1}/{2} {3}:{4}:{5}", Month, Date, Year, Hour, Minute, Second);

}

//constructorpublic Time(System.DateTime dt){

Year = dt.Year;Month = dt.Month;Date = dt.Day;Hour = dt.Hour;Minute = dt.Minute;Second = dt.Second;

}}


C# - Classes – Construtor 2

public class Tester{

static void Main(){

System.DateTime currentTime = System.DateTime.Now;Time t = new Time(currentTime);t.DisplayCurrentTime();System.Console.ReadLine();

}}


C# - Classes - this

A palavra reservada this refere-se à instância actual de um objecto.

A referência this representa 1 ponteiro para todos os métodos não static da

classe.

Existem 3 formas de usar o this (só serão analisadas 2):

Para atribuição de valores a variáveis da classe:

De forma a permitir passar o objecto actual como parâmetro a outro método:

public void SomeMethod (int Hour){

this.Hour = Hour;}

public void FirstMethod (OtherClass otherObject){

otherObject.SecondMethod(this);}


C# - Classes – Copy

public Time(Time existingTimeObject){

this.Year = existingTimeObject.Year;this.Month = existingTimeObject.Month;this.Date = existingTimeObject.Date;this.Hour = existingTimeObject.Hour;this.Minute = existingTimeObject.Minute;this.Second = existingTimeObject.Second;

}

O construtor copy cria um novo objecto através da copia do conteúdo das

variáveis de um objecto existente do mesmo tipo.

C# não fornece nenhum construtor copy, pelo que caso seja necessário, é preciso

implementá-lo.


C# - Membros Estáticos

Membros estáticos são considerados parte da classe.

Para aceder a um membro estático, é necessário indicar primeiro o nome da

classe a que pertence.

Suponhamos que existe uma classe denominada Button que possui objectos

instanciados (btnUpdate e btnDelete). Suponhamos ainda que a classe possui um

método static denominado SomeMethod(). Acede-se ao método da seguinte

forma:

Button.SomeMethod(); E não:

btnUpdate.SomeMethod(); Em C# não é permitido aceder a um método ou membro static através de uma

instância da classe. Dá erro de compilação.



Não é possível saber com exactidão o construtor static será executado, sabe-se

somente que ele será executado após o inicio do programa e antes de ser criada a

primeira instância.

Os membros estáticos são normalmente utilizados como contador de instâncias,

isto é, através deles é possível ter conhecimento de quantas instâncias da classe

existem.

Os membros static são considerados parte da classe pelo que não podem ser

inicializados numa instância. Sendo assim, requerem uma inicialização aquando da

sua declaração.

Os membros static não aceitam acess-modifier (e.g. public)



namespace MyStatic{

using System;public class Cat{

private static int instances = 0;public Cat(){

instances++;}public static void HowManyCats(){

Console.WriteLine("{0} cats adopted", instances);}

}public class Tester{

static void Main(){

Cat.HowManyCats();Cat Frisky = new Cat();Cat.HowManyCats();Cat Whiskers = new Cat();Cat.HowManyCats();Console.ReadLine();

}}

}


C# - Passagem de Parâmetros

Por defeito a passagem de parâmetros para os métodos é efectuada por valor.

Isto significa que quando o valor de um objecto é passado a um método, é criada

uma cópia temporária desse objecto dentro do método. Uma vez executado o

método, a copia é eliminada.

É possível passar parâmetros por referência, usando ref.

Os métodos só retornam um valor. (No entanto podem retornar uma colecção de

valores).



namespace MyConstrutor{

public class Time{

//private member variablesint Year;int Month;int Date;int Hour;int Minute;int Second;// public acessor Methodspublic void DisplayCurrentTime(){

System.Console.WriteLine("{0}/{1}/{2} {3}:{4}:{5}", Month, Date, Year, Hour, Minute, Second);

}

public int GetHour(){

return Hour;}

public void GetTime(ref int h,ref int m,ref int s){

h = Hour;m = Minute;s = Second;

}


C# - Passagem de Parâmetros 2

//constructorpublic Time(System.DateTime dt){

Year = dt.Year;Month = dt.Month;Date = dt.Day;Hour = dt.Hour;Minute = dt.Minute;Second = dt.Second;

}}public class Tester{

static void Main(){

System.DateTime currentTime = System.DateTime.Now;Time t = new Time(currentTime);t.DisplayCurrentTime();

int theHour = 0;int theMinute = 0;int theSecond = 0;t.GetTime(ref theHour,ref theMinute,ref theSecond);System.Console.WriteLine("Current time: {0}:{1}:{2}",

theHour, theMinute, theSecond);System.Console.ReadLine();

}}

}



public void GetTime(ref int h,ref int m,ref int s){


}

// chamada à função.t.GetTime(ref theHour,ref theMinute,ref theSecond);

Como os inteiros são tipos valor, são passados como valor, é efectuada uma copia

no método GetTime().

De forma a tornar o método válido, é necessário efectuar passagem de

parâmetros por referência.



C# impõe que todas as variáveis seja inicializadas entes de ser utilizadas. É essa a razão da inicialização das variáveis theHour, theMinute e the Second a zero, antes de serem utilizadas.

Caso não fossem inicializadas o compilador indicaria o seguinte erro:Use of unassignedlocal variable 'theHour'Use of unassignedlocal variable 'theMinute'Use of unassignedlocal variable 'theSecond'

De forma a evitar este tipo de situações, a linguagem C# fornece uma modificador denominado out, que permite passar uma variável a um método sem necessidade de inicialização.

public void GetTime(out int h, out int m, out int s){


}

// chamada à função.t.GetTime(out theHour, out theMinute, out theSecond);


C# - Sobrecarga - Overloading

Sobrecarga acontece quando se pretende implementar mais do que um método

com o mesmo nome.

O exemplo mais comum da utilização de sobrecarga é no método construtor.

Um método é diferenciado por dois aspectos, o nome e os parâmetros.

void myMethod(int p1);

void myMethod(int p1, int p2);

void myMethod(int p1, string p2);

Modificar o retorno de um método (deixando o nome e os parâmetros iguais) não

permite sobrecarga, e o compilador indicará um erro.


C# - Encapsulamento de dados

Propriedades permitem aos clientes aceder ao estado da classe como se

estivessem a aceder aos membros desta directamente.

Propriedades têm dois objectivos:

Fornecem um interface simples para com o cliente, simulando uma variável membro.

São implementadas como métodos, no entanto, garantem o encapsulamento dos dados,

respeitando as boas práticas de programação orientada a objectos.

public int Hour{

get{

return Hour;}set{

Hour = value;}

}


C# - Encapsulamento de dados

GET

O bloco GET é semelhante a um método da classe que retorna um objecto do tipo

da propriedade.

Sempre que existir uma referência à propriedade (desde que não seja uma

atribuição), o método GET é invocado para ler o valor da propriedade.

Time t = new Time(currentTime);int theHour = t.Hour;

SET

O bloco SET permite a atribuição de um valor e é semelhante a um método da

classe que retorna void.

Sempre que se executar uma atribuição de valor à propriedade, o método SET é

invocado e o parâmetro implícito value toma o valor que se pretende atribuir.

theHour++;t.Hour = theHour;



C#.NET

Parte II

ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 2

Sumário – C#.NET

Estruturas

Operador Overloading

Interfaces

Vectores e Classe Collections

Exemplos retirados do livro:Programming C#, Jesse Liberty – O’Reilly


C# - Estruturas

Uma estrutura consiste num tipo de dados definido pelo utilizador.

As estruturas são semelhantes às classes, pois possuem construtor,

propriedades, métodos, operadores, etc..

Diferem das classes na medida em que não possuem destrutores nem permitem

herança.

Geralmente opta-se pelo uso de estruturas quando se pretende representar tipos

de dados pequenos, simples e similares no seu comportamento e características.

Definição técnica de uma estrutura:

[attributes] [acess-modifiers] struct identifier [:interface-list]

{struct members};


C# - Estruturas

using System;namespace MyStruct{

public struct Location{

private int xVal;private int yVal;public Location (int xCoordinate, int yCoordinate){

xVal = xCoordinate;yVal = yCoordinate;

}

public int x{

get{

return xVal;}set{

xVal = value;}

}


C# - Estruturas

public int y{

get{

return yVal;}set{

yVal = value;}

}

public override string ToString(){

return (String.Format("{0}, {1}", xVal, yVal));}

}


C# - Estruturas

/// <summary>/// Summary description for Class1./// </summary>public class Tester{

public void myFunc (Location loc){

loc.x = 50;loc.y = 100;Console.WriteLine("In MyFunc loc: {0}", loc);

}static void Main(){

Location loc1 = new Location(200,300);Console.WriteLine("Loc1 location: {0}", loc1);Tester t = new Tester();t.myFunc(loc1);Console.WriteLine("Loc1 location: {0}", loc1);

}}

}


C# - Estruturas

Sem destrutor ou construtor por defeito:

Estruturas não possuem destrutores, nem possuem construtor por defeito

sem parametros.

Se não for fornecido construtor, será fornecido um por defeito que colocará

todos os membros a zero. Se existir um construtor, é obrigatório inicializar os

membros.

Sem inicialização:

Não é permitido inicializar os membros dentro da estrutura. Sendo assim é

ilegal proceder à seguinte codificação:privare int xVal = 50;privare int xVal = 50;

Isto tem que ser executado dentro da classe.


C# - Operador Overloading

O operador overloading permite que classes definidas pelo utilizador possuam as

mesmas funcionalidades que os tipos de dados pré-definidos.

Como exemplo suponha que possui uma classe para representar fracções,

Garantir que esta classe possui todas as funcionalidades que tipos de dados pré-

definidos, significa que a classe definida por si tem capacidade de executar as

mesmas operações que as classes de dados pré-definidos. (Exemplo: adicionar

duas fracções, multiplicar duas fracções, e converter fracções em dados do tipo

int).

Fraction theSum = firstFraction + secondFraction;

Como o operador + já existe, será necessário efectuar um overloading do

mesmo, de forma a permitir efectuar uma soma de objectos da nossa classe.



Operador Comparação ==

É bastante comum efectuar o overloading do operador ==, no entanto a

linguagem C# insiste que será necessário efectuar o mesmo para o operador !=.

O mesmo se passa em relação aos operadores < e >, será necessário

implementar o overloading dos operadores <= e =>.

Sendo assim é preferível que se efectue antes um override ao método Virtual

Equals(). Isto permite que a classe seja polimórfica e fornece compatibilidade

com outras linguagens .NET que não suportam o overload de operadores (mas

suportam o método overloading).

A classe objecto implementa o método Equals() da seguinte forma:

public virtual bool Equals (object o)



Operador Comparação ==

Ao efectuar o override do método, garante-se que a classe Fraction actue de forma polimórfica com outros objectos.

Dentro do método é necessário garantir que o objecto a comparar é um objecto do tipo Fraction.

public override bool Equals(object o){

if (! (o is Fraction)){

return false;}return this == (Fraction) o;

}

O operador is é utilizado para garantir que o objecto é compatível com o

operando. Caso o objecto seja Fraction a operação será avaliada.



Operadores de Conversão

A linguagem C# permite conversão implicita e explícita.

Por exemplo converter um int num long consiste numa conversão implítica, pois o

tamanho de um int cabe num long.

A operação inversa traduz-se por uma conversão explícita.

int myInt = 5;long myLong;myLong = myInt // implicitamyInt = (int) myLong // explícita



namespace MyOverloading{

using System;public class Fraction{

private int numerator;private int denominator;public Fraction (int numerator, int denominator){

Console.WriteLine("In Fraction Constructor(int, int)");this.numerator = numerator;this.denominator = denominator;

}

public Fraction(int wholeNumber){

Console.WriteLine("In Fraction Constructor (int)");numerator = wholeNumber;denominator = 1;

}



public static implicit operator Fraction(int theInt){

Console.WriteLine("In implicit conversion to Fraction");return new Fraction (theInt);

}

public static explicit operator int(Fraction theFraction){

Console.WriteLine("In implicit conversion to int");return (theFraction.numerator / theFraction.denominator);

}

public static bool operator == (Fraction lhs, Fraction rhs){

Console.WriteLine("In operator ==");if ((lhs.denominator == rhs.denominator)&& (lhs.numerator == rhs.numerator)){

return true;}// colocar código quando as frações são diferentesreturn false;

}

public static bool operator != (Fraction lhs, Fraction rhs){

return !(lhs==rhs);}



public override bool Equals(object o){

Console.WriteLine("In method Equals");if (! (o is Fraction)){

return false;}return this == (Fraction) o;

}public static Fraction operator + (Fraction lhs, Fraction rhs){

Console.WriteLine("In operator +");if (lhs.denominator == rhs.denominator){

return new Fraction (lhs.numerator+rhs.numerator, lhs.denominator);}// simlistic solution for unlike fractions// 1/2 + 3/4 == (1*4) + (3*2) / (2*4) = 10/8int firstProduct = lhs.numerator * rhs.denominator;int secondProduct = lhs.denominator * rhs.numerator;return new Fraction (firstProduct+secondProduct, lhs.denominator*rhs.denominator);

}public override string ToString(){

string s = numerator.ToString() + "/"+denominator.ToString();return s;

}}




static void Main(){

Fraction f1 = new Fraction(3,4);Console.WriteLine("f1: {0}", f1.ToString());

Fraction f2 = new Fraction(2,4);Console.WriteLine("f2: {0}", f2.ToString());

Fraction f3 = f1+f2;Console.WriteLine("f1 + f2 = f3: {0}", f3.ToString());

Fraction f4 = f3+5;Console.WriteLine("f3 + 5 = f4: {0}", f4.ToString());

Fraction f5 = new Fraction(2,4);if (f5 == f2){

Console.WriteLine("f5: {0} == f2: {1}", f5.ToString(), f2.ToString());}

}}

}


C# - Interfaces

Uma interface consiste basicamente num contracto com o cliente de sobre o comportamento de uma determinada classe ou estrutura.

Quando uma classe implementa uma interface, isto significa, que essa classe garante que suporta todos os métodos, propriedades e eventos da referida interface.

Sintáticamente, uma interface é semelhante a uma clase que possui somente métodos abstractos.

A implementação de uma interface implica relações.

Um carro é um veículo, no entanto pode implementar a capacidade PodeSerCompradoComRecursoCredito.

[attributes] [access-modifier] interface interface-name [:base-list]

{interface-body}


C# - Interfaces

namespace MyInterface{

using System;// declare the interfaceinterface IStorable{

// no access modifiers, methods are public// no implementationvoid Read( );void Write(object obj);int Status { get; set; }

}// Take our interface out for a spinpublic class Tester{

static void Main( ){

// access the methods in the Document objectDocument doc = new Document("Test Document");doc.Status = -1;doc.Read( );Console.WriteLine("Document Status: {0}", doc.Status);

}}


C# - Interfaces

// create a class which implements the IStorable interfacepublic class Document : IStorable{

public Document(string s){Console.WriteLine("Creating document with: {0}", s);

}// implement the Read methodpublic void Read( ){

Console.WriteLine("Implementing the Read Method for IStorable");

}// implement the Write methodpublic void Write(object o){

Console.WriteLine("Implementing the Write Method for IStorable");

}// implement the propertypublic int Status{

get {return status;

}set{

status = value;}

}// store the value for the propertyprivate int status = 0;

}


C# - Interfaces

Implementando mais do que uma interface

É permitido que uma classe implemente mais do que uma interface, bastando

para isso indicar o nome das interfaces, separadas por uma vígula.

public class Document : IStorable, ICompressible

Extensão de interfaces

É possível a uma interface herdar as caraterísticas de outra interface.

interface ILoggedCompressible : ICompressible

As classes são livres de implementar a interface que lhes convém mais, no

entanto classes que implementem a interface ILoggedCompressible têm que

implementar os métodos de ambas as interfaces.


C# - Interfaces

Junção de Interfaces.

É possível desenvolver novas interfaces a partir da junção de interfaces já existentes e opcionalmente adicionar novos métodos ou propriedades.

interface IStorableCompressible : IStorable, ILoggedCompressible

{void LogOriginalSize();

}

Esta interface combina os métodos das outras duas interfaces e implementa um

novo método que permite guardar o tamanho original do item antes da

compressão.


C# - Interfaces

namespace MyInterfaceCombining{

using System;interface IStorable {

void Read();void Write(object obj);int Status { get; set; }

}// here's the new interfaceinterface ICompressible {

void Compress();void Decompress();

}// Extend the interfaceinterface ILoggedCompressible : ICompressible {

void LogSavedBytes();}// Combine Interfacesinterface IStorableCompressible : IStorable, ILoggedCompressible {

void LogOriginalSize();}// yet another interfaceinterface IEncryptable {

void Encrypt();void Decrypt();

}


C# - Interfaces

public class Document : IStorableCompressible, IEncryptable{

// the document constructorpublic Document(string s) {

Console.WriteLine("Creating document with: {0}", s);

} // implement IStorablepublic void Read(){

Console.WriteLine("Implementing the Read Method for IStorable"); }public void Write(object o){

Console.WriteLine("Implementing the Write Method for IStorable"); }public int Status{

get{return status;

}set{

status = value;}

}


C# - Interfaces

// implement ICompressiblepublic void Compress() {

Console.WriteLine("Implementing Compress"); } public void Decompress() {

Console.WriteLine("Implementing Decompress"); }// implement ILoggedCompressiblepublic void LogSavedBytes() {

Console.WriteLine("Implementing LogSavedBytes");} // implement IStorableCompressible public void LogOriginalSize() {

Console.WriteLine("Implementing LogOriginalSize");}// implement IEncryptablepublic void Encrypt() {

Console.WriteLine("Implementing Encrypt");

}public void Decrypt() {

Console.WriteLine("Implementing Decrypt");

}// hold the data for IStorable's Status propertyprivate int status = 0;

}


C# - Interfaces


static void Main(){

// create a document objectDocument doc = new Document("Test Document");// cast the document to the various interfacesIStorable isDoc = doc as IStorable;if (isDoc != null){

isDoc.Read();}else

Console.WriteLine("IStorable not supported");

ICompressible icDoc = doc as ICompressible;if (icDoc != null){

icDoc.Compress();}else

Console.WriteLine("Compressible not supported");


C# - Interfaces

IStorableCompressible isc = doc as IStorableCompressible;if (isc != null){

isc.LogOriginalSize(); // IStorableCompressibleisc.LogSavedBytes(); // ILoggedCompressibleisc.Compress(); // ICompressibleisc.Read(); // IStorable

}else{

Console.WriteLine("StorableCompressible not supported");}

IEncryptable ie = doc as IEncryptable;if (ie != null){

ie.Encrypt();}else

Console.WriteLine("Encryptable not supported");}

}

}


C# - Interfaces

Implementação explícita de uma Interface.

A implementação explícita torna-se necessário quando uma classe implementa duas interfaces que contêm pelo menos um método com o mesmo nome.interface IStorable{

void Write();void Read()

}

interface ITalk{void Talk();void Read()

}void ITalk.Read()

{Console.WriteLine(″Implementig ITalk.Read″);

}


C# - Vectores

Um vector (Array) consiste numa coleção indexada de dados do mesmo

tipo.

Relativamente à liguagem C#, os vectores diferem das outras

linguagens na medida em que todos os dados constituintes do vector

são objectos.

Declaração de um vector: type [] array-name;

Os parênteses rectos indicam ao compilador que se trata de um vector.

A instanciação de um vector é efectuada recorrendo à palavra new:

int[] myIntArray;myIntArray = new int[5];

A declaração anterior permitiu declarar um vector de 5 elementos

inteiros, e alocar memória para os mesmos.


C# - Vectores

Valores por defeito

Ao criar um vector de elementos do tipo valor, cada elemento do vector será

inicializado a zero.

Se o vector for do tipo referência cada elemento do vector será inicializado a

null, ou seja, se tentar aceder a um elemento do vector sem o ter inicializado

primeiro, provocará uma excepção.

O seguinte exemplo:

Button[] myButtonArray = new Button [3];

Não cria um array com três objectos Button, mas sim um vector de 3 elementos

do tipo Button. Para conter objectos deste género, será necessário primeiro

inicializar cada elemento com um objecto deste tipo.


C# - Vectores

Aceder aos elementos

A indexação de um vector é inicializada a zero, e cada elemento terá que ser

acedido pela sua posição dentro de [].

Como referido anteriormente, os vectores são objectos, logo possuem

propriedades, sendo uma delas a length (tamanho). Como os vectores são

indexados a zero, é necessário ter em consideração que a última posição do

vector é length-1


C# - Vectores

namespace MyArrayFor{

using System;public class Employee{

private int empID;public Employee(int empID){

this.empID = empID;}

public override string ToString(){

return empID.ToString();}

}


C# - Vectores

public class Tester {

static void Main(){

int[] intArray;Employee[] empArray;intArray = new int[5];empArray = new Employee[3];//populate the arrayfor (int i = 0; i<empArray.Length;i++){

empArray[i]= new Employee(i+5);}

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

Console.WriteLine(intArray[i].ToString());}

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

Console.WriteLine(empArray[i].ToString());}

}}

}


C# - Vectores - foreach

public class Tester {

static void Main(){

int[] intArray;Employee[] empArray;intArray = new int[5];empArray = new Employee[3];//populate the arrayfor (int i = 0; i<empArray.Length;i++){

empArray[i]= new Employee(i+5);}

foreach (int i in intArray){

Console.WriteLine(intArray[i].ToString());}

foreach (Employee e in empArray){

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

}}

}


C# - Vectores

Parâmetros - params

Permite a passagem de diversos parâmetros para um método, sem ser

necessário especificar no método quantos parâmetros são.

namespace MyArrayParams{

using System;public class Tester{

static void Main (){

Tester t = new Tester();t.DisplayVals(5,6,7,8);int [] explicitArray = new int[5] {1,2,3,4,5};t.DisplayVals(explicitArray);

}public void DisplayVals (params int[] intVals){

foreach (int i in intVals){

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

}}

}


C# - Vectores Multidimensionais

Regulares

Um vector multidimensional regular é um vector que possui o mesmo

número de colunas para todas as linhas.

Num array multimensional de duas dimensões, a 1ª consiste no número

de linhas enquanto a 2ª dimensão representa o número de colunas.

Declaração de um vector de duas dimensões:

int [,] myRectangleArray = new int [2,3];

A existência de uma vírgula indica que o vector é de duas dimensões

(duas vírgulas indica 3 dimensões e por aí adiante).

Neste género de vectores também é possível utilizar a inicialização

através de {}:

int [,] myRectangleArray = { {0,1,2}, {3,4,5}, {6,7,8}, {9,10,11}};


C# - Vectores Multidimensionais

Jagged

Um vector vector jagged consiste num vector de vectores, onde cada linha não

tem obrigatoriamente de ter o mesmo número de colunas das anteriores.

Ao criar um vector jagged, define-se unicamente o número de linhas do mesmo.

Cada linha irá conter então um outro vector, o qual terá o tamanho desejado.

Definição de um vector jagged:

int [][] myMyJagged = new int [rows][];


C# - Vectores - jagged

namespace MyJaggedArray{

using System;


static void Main(){

const int rows = 4;// declare the jagged array as 4 rows highint[][] jaggedArray = new int[rows][];// the first row has 5 elementsjaggedArray[0] = new int[5]; // a row with 2 elementsjaggedArray[1] = new int[2]; // a row with 3 elementsjaggedArray[2] = new int[3]; // the last row has 5 elementsjaggedArray[3] = new int[5];


C# - Vectores - jagged

// Fill some (but not all) elements of the rows jaggedArray[0][3] = 15;jaggedArray[1][1] = 12;jaggedArray[2][1] = 9;jaggedArray[2][2] = 99;jaggedArray[3][0] = 10;jaggedArray[3][1] = 11;jaggedArray[3][2] = 12;jaggedArray[3][3] = 13;jaggedArray[3][4] = 14;

for (int i = 0;i < 5; i++){Console.WriteLine("jaggedArray[0][{0}] = {1}", i,jaggedArray[0][i]);

}


}


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

Console.WriteLine("jaggedArray[3][{0}] = {1}", i,jaggedArray[3][i]);}

}}

}


C# - Vectores - ArrayList

O problema com o tipo vector é o seu tamanho fixo. Se não for possível ter um

conhecimento antecipado de quantos objectos será necessário armazenar, corre-

se o risco de declarar ou um vector muito grande, ou um vector que não

preenche as necessidades.

Sendo assim a linguagem C# possui uma classe de dados denominada ArrayList,

cujo tamanho pode ser dinâmicamente incrementado à medida das necessidades.

Esta classe possui métodos e propriedades que ajudam bastante na sua

utilização.


C# - Vectores - ArrayList

namespace MyArrayList{

using System;using System.Collections;// a simple class to store in the arraypublic class Employee{

public Employee(int empID){

this.empID = empID;}public override string ToString(){

return empID.ToString();}public int EmpID{

get{

return empID;}set{

empID = value;}

}private int empID;

}


C# - Vectores - Dicionários

Um dicionário consiste numa colecção de dados que associa uma chave a um

valor.

A Framework .NET permite que um dicionário possa associar qualquer tipo de

chave (string, integer, object, etc) a qualquer tipo de valores (string, integer,

object, etc).

A característica mais importante de um dicionário é que seja de fácil utilização,

isto é, que seja fácil de inserir novos valores e rápido a devolver os mesmos.

Hashtables

É um tipo de dicionário optimizado para aceder a valores rápidamente.

Numa hash table cada valor é armazenado num bucket, o qual é numerado de

forma semelhante ao offset de um vector.

A chave de uma hash table não necessita de ser inteira.


C# - Vectores - hashtables

namespace MyHash{

using System;using System.Collections;public class Tester{


// Create and initialize a new Hashtable.Hashtable hashTable = new Hashtable( );hashTable.Add("000440312", "Jesse Liberty");hashTable.Add("000123933", "Stacey Liberty");hashTable.Add("000145938", "John Galt");hashTable.Add("000773394", "Ayn Rand");

// access a particular itemConsole.WriteLine("myHashTable[\"000145938\"]: {0}",

hashTable["000145938"]);}

}}


C# - Vectores - hashtables

namespace MyHashProperties{



// Create and initialize a new Hashtable.Hashtable hashTable = new Hashtable( );hashTable.Add("000440312", "George Washington");hashTable.Add("000123933", "Abraham Lincoln");hashTable.Add("000145938", "John Galt");hashTable.Add("000773394", "Ayn Rand");

// get the keys from the hashTableICollection keys = hashTable.Keys;// get the valuesICollection values = hashTable.Values;// iterate over the keys ICollectionforeach(string key in keys){

Console.WriteLine("{0} ", key);}// iterate over the values collectionforeach (string val in values){

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

}}

}


C# - Vectores - IDictionaryEnumerator

namespace MyDictionaryEnumerator{



// Create and initialize a new Hashtable.Hashtable hashTable = new Hashtable( );hashTable.Add("000440312", "George Washington");hashTable.Add("000123933", "Abraham Lincoln");hashTable.Add("000145938", "John Galt");hashTable.Add("000773394", "Ayn Rand");

// Display the properties and values of the Hashtable.Console.WriteLine( "hashTable" );Console.WriteLine( " Count: {0}", hashTable.Count );Console.WriteLine( " Keys and Values:" );PrintKeysAndValues( hashTable );

}public static void PrintKeysAndValues( Hashtable table ){

IDictionaryEnumerator enumerator = table.GetEnumerator( );while ( enumerator.MoveNext( ) )

Console.WriteLine( "\t{0}:\t{1}",enumerator.Key, enumerator.Value );Console.WriteLine( );

}}

}


C# - Vectores

Para além dos vectores anteriormente referidos, existem ainda os

seguintes:



C#.NET

Parte III


Sumário – C#.NET

ADO.NET

DataSet

DataTable

DataColumn

DataRow

DataGrid


C# - ADO.NET

O ADO.NET fornece acesso consistente a fontes de dados, como por exemplo o SQL Server, assim como a outras fontes acessíveis via OLE

DB, XML ou ODBC.

As aplicações podem utilizar o ADO.NET para estabelecer ligações a bases de dados por forma a manipular os dados.

As classes para trabalhar com o ADO.NET estão no System.Data.xxxx, em que xxxx refere-se à especialização do fornecedor de acesso aos dados.

Deste forma, pode-se dizer que o ADO.NET é um conjunto de classes para trabalhar com dados.

Principais características: Um sucessor do ADO mais flexível

Um sistema desenhado para ambientes desconectados

Um modelo de programação com suporte avançado para XML

Um conjunto de classes, interfaces, estruturas e enumerações que gerem o acesso a dados dentro do framework


C# - ADO.NET

A nível do armazenamento de Dados, o ADO.NET suporta vários tipos:

Não estruturados;

Estruturados, não-hierárquicos

Ficheiros CSV (Com ma Separated Value), Folhas Microsoft Excel, Ficheiros, o Microsoft

Exchange, o..

Hierárquicos

Documentos XML e outros

Bases de Dados Relacionais

SOL Server, Oracle, Access, ODBC, etc


C# - ADO.NET

Um fornecedor de dados para ADO.NET é um conjunto de classes que pode ser usado para efectuar ligações a bases de dados, manipular e

actualizar os dados: SQL Server .NET Data Provider

OLE DB .NET Data Provider

ODBC .NET Data Provider

Outros (DB2/400, MySQL, ...)

XxxConnection -exemplo, SqlConnection o XxxTransaction -exemplo, SqlTransaction

o XxxException -exemplo, SqlException

o XxxError -exemplo, SqlError

XxxCommand -exemplo, SqlCommand o XxxParameter -exemplo, SqlParameter

XxxDataReader -exemplo, SqlDataReader

XxxDataAdapter -exemplo, SqlDataAdapter

XxxPermission -exemplo, SqlClientPermission


C# - ADO.NET

Cenários Conectados

Um cenário conectado é aquele no qual os utilizadores estão permanentemente ligados à bases de dados

Vantagens:

É mais fácil exercer segurança ao nível do ambiente;

A concorrência é mais fácil de controlar;

Os dados estão mais actualizados que nos outros cenários;

Desvantagens

É necessário haver uma ligação constante ao servidor;

Escalabilidade;


C# - ADO.NET

1. Abrir ligaçãoSqlConnection conn = new SqlConnection("SERVER=SQLSERVER; INTEGRATED SECURITY = TRUE; INITIAL CATALOG=ISEP");conn.Open();OU (http://msdn2.microsoft.com/en-us/library/8xx3tyca(VS.80).aspx)using (SqlConnection connection = new SqlConnection("Server=MSSQL1;uid=xxx;pwd=xxx;database=master")) { connection.Open(); command.ExecuteNonQuery("USE " + databaseName); }

2. Executar comandoSqlCommand cmd = new SqlCommand();cmd.Connection = conn;cmd.CommandText = "SELECT cod, descricao FROM detalhes WHERE zona=42 “;SqlDataReader reader = cmd.ExecuteReader();

3. Processar linhas no readerwhile(reader.Read()){

int cod = (int)reader[O];cmbDescricao. Items.Add(reader[1].ToString());

}

4. Fechar readerif(!reader.IsClosed)

reader.Close();

5. Fechar ligaçãoconn.Close();


C# - ADO.NET

Cenários Desconectados

Num ambiente desconectado, um sub-conjunto de dados pode ser copiado e modificado independentemente e mais tarde as alterações podem ser introduzidas de novo na base de dados

Vantagens

Pode-se trabalhar a qualquer altura e pode-se efectuar uma ligação à base de dados apenas quando necessário;

Outros utilizadores podem usar os recursos;

Este tipo de ambientes aumenta a escalabilidade e desempenho das aplicações;

Desvantagens

Os dados nem sempre estão actualizados;

Podem ocorrer conflitos de dados que têm que ser resolvidos;


C# - ADO.NET

1. Abrir a ligaçãoSqlConnection conn = new SqlConnection("SERVER=SQLSERVER; INTEGRATED SECURITY = TRUE; INITIAL

CATALOG=ISEP");conn.open();

2. Preencher o DataSetSystem.Data.DataSet ds = new System.Data.DataSet(); System.Data.Sql.sqlDataAdapter da =new System.Data.Sql.SqlDataAdapter();SqlCommand cmd = new SqlCommand();cmd.CommandText = "SELECT * FROM [DETALHES]";cmd.Connection = conn;da.SelectCommand = cmd;da.Fill(ds);

3. Fechar a ligaçãoconn.Close() ;

4. Processar o DataSetforeach(DataRow r in ds.Tables[O] .Rows)

r ["preco"] = r[preco] * 1.05;5. Abrir a ligação

conn.Open() ;6. Actualizar a fonte de dados

System.Data.Sql.SqlDataAdapter da = new System.Data.Sql.SqlDataAdapter("SELECT * FROM [DETALHES]", conn); System.Data.Sql.SqlCommandBuilder cb =new System.Data.Sql.SqlCommandBuilder(da);da.Update(ds) ;

7. Fechar a ligaçãoconn.Close() ;


C# - ADO.NET

Namespaces necessários

System.Data – para as classes base do ADO.net (ex, DataSet).

System.Data.SqlClient – para as classes correspondentes ao provider para SQL Server;

System.Data.OleDb – para as classes correspondentes ao provider para OLE DB;

System.Data.SqlTypes – para as classes correspondentes aos tipos de dados nativos do SQL Server.

System.Data.Common – para as estruturas de dados, classes e interfaces comuns a todos os providers (ex, DataSet)

System.Xml – para as classes de manipulação de XML via DataSet;


C# - ADO.NET

// Definir uma ligação a um fornecedor do tipo OLEDB para Access OleDbConnection conn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0iData Source= C:\DSN\Teste.mdbiPersist Security Info=False");

//Abrir a ligaçãoconn.Open();//Definir um novo comando do tipo OLEDBOleDbCommand cmd = new OleDbCommand();//Colocar o texto do comandocmd.CommandText = "SELECT NOME FROM PESSOA WHERE NUMERO = ?“;//Indicar ao comando qual é a ligação que vai usarcmd.Connection = conn;//Definir um parametro do tipo inteiro para conter o "Número" OleDbParameter parm = cmd.Parameters.Add(new OleDbParameter("@Numero", OleDbType.Integer));//Colocar o valor do parametro "Número". Quero saber o nome do cliente cujo código é 1...cmd.Parameters["@Numero"] .Value=l;//Executar o comando que só irá retornar um valor//Converter o resultado numa string//Colocar o valor de retorno na respectiva caixa de textotxtNome.Text = cmd.ExecuteScalar() .ToString();//Fechar a ligaçãoconn.Close();

Executar comandos que retornem um só registo


C# - ADO.NET

//Definir uma ligação a um fornecedor do tipo OLEDB para Access OleDbConnection conn = new

OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0iData Source= C:\DSN\Teste.mdbiPersist Security Info=False");//Abrir a ligaçãoconn.Open();//Definir um novo comando do tipo OLEDBOleDbCommand cmd = new OleDbCommand();//Colocar o texto do comandocmd.CommandText = "INSERT INTO TRABALHOS VALUES(?, ?)";//Indicar ao comando qual é a ligação que vai usarcmd.Connection = conn;//Definir os parametros para inserir os valoresOleDbParameter parmNumero = cmd.Parameters.Add(new OleDbParameter("@Numero", OleDbType.Integer));OleDbParameter parmNome = cmd.Parameters.Add(new OleDbParameter("@Nome", OleDbType.Char)) ;// Inserir os valoresfor(int i=O; i<cmbNomes.Items.Count; i++){

parmNumero.Value = i+l;parmNome.Value = cmbNomes.Items[i];//Executar o comando para inserir os valorescmd.ExecuteNonQuery();

}//Fechar a ligaçãoconn.Close();

Executar comandos que não retornem registos (inserir, actualizar ou remover registos)


C# - ADO.NET

//Definir uma ligação a um fornecedor do tipo OLEDB para Access OleDbConnection conn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source= C:\DSN\Teste.mdb;Persist Security Info=False");

//Abrir a ligaçãoconn.Open() ;//Definir um novo comando do tipo OLEDBOleDbCommand cmd = new OleDbCommand();//Colocar o texto do comandocmd.CommandText = "SELECT NOME FROM PESSOA";//Indicar ao comando qual é a ligação que vai usarcmd.Connection = conn;//Definir um DataReader para ler os dados//DataReader = forward only, read only. Muito rápido.//Executar o comando e associá-lo ao readerOleDbDataReader reader = cmd.ExecuteReader();//Percorrer o reader e colocar os valoreswhile(reader.Read())cmbNomes.Items.Add(reader[O] .ToString());//Se o reader não estiver fechado, fechar...if( !reader.IsClosed )

reader.Close();//Fechar a ligaçãoconn.Close() ;

Executar comandos que retornem registos para preenchimento de informação


C# - DataSet

Os resultados obtidos através da execução de comando através do ADO.NET podem ser processados directamente ou colocados num objecto ADO.NET DataSet.

O objecto Dataset contém um ou mais objectos Data Table. Assim, os dados que vão “alimentar” a aplicação estão armazenados neste objecto.

Construtores

Eventos

usado pelo .Net. Não é para ser utilizado directamenteDataset(SerializationInfom StreamingContext)

Cria um Dataset, com um determinado nomeDataset(string Nome)

Cria um DatasetDataset()

Ocorre quando o método Merge falha MergeFailed


C# - DataSet

Propriedades

Colecção de tabelas. Contém objectos DataTableTables

Colecção de relações. Contém objectos DataRelationRelations

Prefixo do namespace usado quando o Dataset grava ou carrega os dados para o XMLPrefix

Nome do namespace usado quando o Dataset grava ou carrega os dados para o XMLNamespace

Indica se o Dataset tem ou não errosHasErrors

Definições de linguagens, usadas para comparar stringsLocale

Colecção de propriedades dinâmicasExtendedProperties

Controla se o Dataset vai ou não forçar constraintsEnforceConstraints

Indica se o Dataset está ou não em modo DesignDesignMode

Nome do DatasetDatasetName

Controla se as comparações de strings são ou não sensíveis a Maiúsculas / MinusculasCaseSensitive


C# - DataSetMétodos

Escreve o conteúdo do esquema do DataSet em XML Schema, para um ficheiro, stream, TextReader ou XMLReader.

WriteXmlSchema

Escreve o conteúdo do DataSet em XML, para um ficheiro, stream, TextReader ou XMLReader.WriteXml

Faz um reset ao Dataset, de forma a que fique com estado original do DatasetReset

Lê informação XML schema a partir de um ficheiro, stream, TextReader ou XMLReader.ReadXmlSchema

Lê dados XML a partir de um ficheiro, stream, TextReader ou XMLReader.ReadXml

Carrega e sincroniza dados de outro Dataset, DataTable ou Array de DataRows para o Dataset que chama o método.

Merge

Indica se há alguma alteração pendente no Dataset.HasChanges

Devolve o schema do Dataset em XML (string)GetXmlSchema

Devolve os dados do Dataset em XML (string)GetXml

Cria um novo Dataset com o mesmo schema, mas apenas com as linhas que foram modificadas do Dataset original

GetChanges

Novo Dataset com o mesmo schema e com os mesmos dadosCopy

Cria um novo Dataset com o mesmo schema, mas sem dadosClone

Apaga todos os DataTable’s do DatasetClear

Usado internamente pelo Visual Studio .Net, antes e depois de adicionar informação sobre o Schema do Dataset

BeginInit e EndInit

Aceita / Rejeita todas as alterações pendentes Dentro do Dataset. Funciona com um Commit / Rollback local. Aceita todas as alterações pendentes Dentro do Dataset. Funciona com um Commit local.

AcceptChanges– RejectChanges


C# - DataSet

//Definir um DataSet chamado "AULAS"DataSet dsAulas = new DataSet("AULAS");//Definir as DataTableDataTable dtAlunos;DataTable dtInscricoes;//Dizer que as tabelas pertencem ao DataSetdtAlunos = dsAulas.Tables.Add("ALUNOS");dtInscricoes = dsAulas.Tables.Add("INSCRICOES");//Definir a estrutura das tabelasdtAlunos.Columns.Add("NUMERO", typeof(int));dtAlunos.Columns.Add("NOME", typeof(string));dtInscricoes.Columns.Add("NUMERO_ALUNO", typeof(int)); dtInscricoes.Columns.Add("NUMERO_DISCIPLINA", typeof(int));//Definir as chaves primárias das tabelas dtAlunos.Constraints.Add("PK_ALUNOS", dtAlunos.Columns["NUMERO"], true); dtInscricoes.Constraints.Add("PK_INSCRICOES", newDataColumn[] {dtInscricoes.Columns["NUMERO_ALUNO"], dtInscricoes.Columns["NUMERO_DISCIPLINA"]}, true);//Definir as relações entre as tabelas dsAulas.Relations.Add("R_ALUNO_DISCIPLINAS",dtAlunos.Columns["NUMERO"],dtInscricoes.Columns["NUMERO_ALUNO"]);//Mostrar o DataSet numa grelhadgAulas.DataSource = dsAulas;//Mostrar uma tabela especifica do DataSetdgAulas.DataMember = "ALUNOS";

Criar um DataSet programaticamente


C# - DataSet

Um objecto Dataset consiste num repositório de dados em memória, no lado do cliente, e apresenta-se como o principal representante do conjunto de objectos do modelo ADO.NET a suportar a arquitectura desconectada.

Um objecto Dataset nada sabe acerca da fonte de dados de onde provêm os seus dados, podendo estes provirem de diferentes bases de dados. Isto acontece porque, o objecto Data Adapterserve de ponte entre o DataSet e a base de dados, pois utiliza a informação de como ligar e aceder à base de dados (a partir dos objectos connection e command), ao mesmo tempo que proporciona métodos para preencher o DataSet de dados, assim como para efectivar a alteração dos dados, realizada ao nível do DataSet, na fonte de dados.

Um objecto Dataset consiste numa hierarquia de um ou mais objectos Data Table e Data Relation.


C# - DataSet


C# - DataSet

Um objecto Data Table consiste de um ou mais objectos Data Column, Data Rowe Constraint.

Um objecto Data Relation define o modo como as tabelas de um objecto Datasetestão relacionadas. O objecto Data Relation é essencialmente utilizado para gerir as restrições e, desse modo, simplificar a navegação entre tabelas relacionadas.

Os objectos Data Column definem os dados em cada coluna da tabela, incluindo o seu nome, tipo de dados, etc.

Os objectos Data Row contêm os dados para cada registo da tabela.

Os objectos Constraint são utilizados para manter a integridade dos dados. Uma restrição de chave primária assegura que os valores numa coluna, tal como a coluna de chave primária, são únicos. Uma restrição de chave forasteira determina como os registos de uma tabela são afectados quando os registos correspondentes duma tabela relacionada são alterados ou eliminados.


C# - DataTable

Construtores

usado pelo .Net. Não é para ser utilizado directamenteDataTable(SerializationInfo

StreamingContext)

Cria um novo DataTable com um determinado nomeDataTable(nome)

Cria um novo DataTableDataTable()

Antes de uma linha ser apagadaRowDeleting

Depois de uma linha ser apagadaRowDeleted

Antes do conteúdo de uma linha ser alteradoRowChanging

Depois do conteúdo de uma linha ser alteradoRowChanged

Antes do conteúdo de uma coluna ser alteradoColumnChanging

– Depois do conteúdo de uma coluna ser alteradoColumnChanged

Eventos


C# - DataTable

Propriedades

Nome da DataTableTableName

Colecção de linhas (DataRow) da tabelaRows

Array de DataColumns com a chave primáriaPrimaryKey

Colecção com DataRelations, que contêm dados “pai”ParentRelations

Prefixo do namespace usado quando o DataTable grava ou carrega os dados para o XMLPrefix

Nome do namespace usado quando o DataTable grava ou carrega os dados para o XMLNamespace

Quantidade (em linhas-rows) de memória que o DataTable reserva inicialmenteMinimumCapacity

Definições de linguagens, usadas para comparar stringsLocale

Indica se há algum erro na tabelaHasErrors


Indica se o DataTable está em modo designDesignMode

DataView por defeitoDefaultView

Dataset onde o DataTable está (null se não estiver associado a nenhums dataset)DataSet

Colecção de constraintsConstraints

Colecção de colunas (DataColumn)Columns

Colecção com DataRelations, que contêm dados dependentesChildRelations

Controla se é ou não sensível a maiusculas/minu.CaseSensitive


C# - DataTable

Métodos

Devolve um array de DataRows, baseado num determinado critério de pesquisaSelect

Faz um reset ao DataTable, de forma a que fique com estado original do DataTableReset

Cria e devolve uma nova linha do DataTable (vazia)NewRow

Adiciona uma linha ao DataTable, passando os valores dessa linha através de um arrayLoadDataRow

Importa uma linha já existente para o DataTableImportRow

Devolve um array de DataRows, referentes às linhas que têm errosGetErrors

Cria um novo DataTable com o mesmo schema, mas apenas com as linhas que foram modificadas do DataTable original

GetChanges

Devolve o valor de uma expressão agregada (ex: sum, max,...), baseado no conteudo do DataTableCompute

Cria um novo DataTable, com o mesmo schema e mesmo dadosCopy

Cria um novo DataTable, com o mesmo schema, mas sem dadosClone

Apaga todas as linhas do DataTableClear

Desliga e volta a ligar as constraints. Util para carregar dadosBeginLoadData – EndLoadData

Usado internamente pelo Visual Studio .Net, antes e depois de adicionar informação sobre o Schema do DatasetBeginInit – EndInit

– Aceita/rejeita todas as alterações pendentes da tabela (como commit/rollback para dados locais)AcceptChanges – RejectChanges


C# - DataColumnPropriedades

Controla se a coluna necessita ou não de ter valores unicosUnique

DataTable a que pertence a colunaTable

Controla se a coluna é ou não só de leituraReadOnly

Indice da coluna na colecção de colunas do DataTableOrdinal

Prefixo do namespace usado grava ou carrega os dados para o XMLPrefix

Nome do namespace usado quando grava ou carrega os dados para o XMLNamespace

Tamanho máximo das colunas stringMaxLength


linhasControla como o ADO.Net calcula o valor da coluna (para colunas baseadas em expressões)Expression

Controla o valor por defeito para esta coluna, quando são criadas novasDefaultValue

Controla o tipo de dados armazenado pela colunaDataType

Nome do objecto DataColumnColumnName

Controla como o ADO.Net armazena o conteudo da coluna em XMLColumnMapping

Titulo da coluna quando numa grelhaCaption

controla quanto o autoincrementa saltaAutoIncrementStep

1º valor do autoincrementAutoIncrementSeed

Controla se a coluna gere valores autoincrementAutoIncrement

– Controla se a coluna aceita ou não NULLsAllowDBNull


C# - DataRow

Propriedades

Tabela a que pertence o DataRowTable

Estado da linha. Valores possíveis: Added; Deleted; Detached (linha não pretence ainda a um DataTable); Modified; Unchanged

RowState

Informação sobre o erro associada à linhaRowError

Acesso aos valores da linha, usando um array de objectosItemArray

Propriedade indexada que permite o acesso (ler e alterar) os valores da linha. Indice- nº ordem da coluna; nome; referência ao DataColumn correspondente.

Item

Indica se a linha tem ou não errosHasErrors-


C# - DataRow

Métodos

Alterar a informação de erro da linha “pai”, com base numa DataRelatioSetParentRow

Alterar a informação de erro de uma determinada colunaSetColumnError

Indica se uma determinada coluna está ou não NulaIsNull-

Indica se a linha tem não uma determinada versão dos dadosHasVersion

Devolve um array de DataRows, para as linhas “pai” da actual, com base numa DataRelationGetParentRows

Devolve um DataRow, para a linha “pai” da actual, com base numa DataRelationGetParentRow

Array de DataColumns, com todas as colunas que têm erros nesta linhaGetColumnsInError

Obtem informação de erro sobre uma coluna específicaGetColumnError

Devolve um array de DataRows, para linhas dependentes da actual, com base numa DataRelation

GetChildRows

Apaga a linha. Na realidade, a linha fica apenas marcada para apagar (RowState = Deleted)Delete

Limpa os erros associados à linhaClearErrors

Inicia, Cancela ou Guarda (localmente) o processo de alteração dos dados da linhaBeginEdit – CancelEdit – EndEdit

Aceita ou Rejeita as alterações da linha.AcceptChanges – RejectChanges


C# - Exemplos

Exemplos:

DataRow row= Tabela.Rows.Find(“ValorAProcurar”);

DataRow row= Tabela.Rows.Find(3323);

...

object[] criterio = new object[] {“Valor1”, 4343};

DataRow row= Tabela.Rows.Find(criterio);

Find- Método da DataRowColection, que procura uma linha com base na sua chave primária


C# - Exemplos

DataRow[] Linhas = Tabela.Select(“(Pais=’PT’) and (cidade <> ‘Leiria’)”);

...

Exemplos de Expressões no Selectxpto LIKE ‘%a’ - xpto acaba em axpto LIKE ‘a%’ – xpto começa por axpto = ‘O’’Brian’ - xpto = O’Brian (1 plica = 2 plicas)#01/01/2003# - Datas[campo com espacos] = 23 - Campos podem ter espaços, desde que fiquem entre parentesis rectos

Ordenar linhas devolvidas pelo SelectDataRow[] Linhas = Tabela.Select(“Pais=’PT’, “Cidade DESC”);DataRow[] Linhas = Tabela.Select(“Pais=’PT’, “Cidade ASC”);

Linhas com determinado RowStatus devolvidas pelo Select DataViewRowState Estado;Estado = DataViewRowState.ModifiedOriginal | DataViewRowState.DeletedDataRow[] Linhas = Tabela.Select(“”, “”, Estado); //Devolve as linhas que foram modificadas ou apagadas.

Select- Método da DataTable, que devolve um array de linhas, baseado num determinado critério.


C# - DataGrid

O contolo DataGrid permite apresentar dados de uma tabela ou de uma colecção.

Os programadores podem selecionar quais as colunas que vão apresentar dados, personalizar as colunas, dotá-las de um cabeçalho e tratar os eventos que ocorrem quando o utilizador selecciona uma linha ou célula específica.

Fontes de dados que podem ser apresentadas numa DataGrid:

Objecto DataTable;

Objecto DataView;

Objecto ArrayList;

Qualquer componente que implemente os interfaces IListSources ou IList;

É permitido apresentar um objecto DataTable contido num DataSet.

//myDataSet may contain more than one DataTableDataTable myDataTable = myDataSet.Tables[“Customers”];dataGrid1.DataSource = myDataTable;


C# - DataGrid

Por defeito o objecto DataGrid apresenta todas as colunas e todas as linhas da fonte de dados (DataSource), sendo o título das colunas o nome das colunas.

A propriedade CurrentCell permite obter ou especificar o Focus de uma determinada célula.

//Set Focus to cell 3,5mydataGrid1.CurrentCell =new DataGridCell(3,5);

O objecto DataGrid pode ser formatado em termos de apresentação. Pode-se modificar as cores do background, das linhas, dos títulos, das linhas selecionadas, e etc.

De forma a criar um estilo para a DataGrid, é instanciar um objecto DataGridTableStyle, adicionar um objecto DataColumnGridStyle a cada coluna que se pretende apresentar e finalmente associar o DataGridTableStyle à propriedade TableStyles do objecto DataGrid


C# - DataGrid

//Definir um DataSet chamado "AULAS“DataGridTableStyle ts1 = new DataGridTableStyle();ts1.MappingName = “Customers”;

/* Adicionar GridColumnStyle e associar um nome ao DataColumn na DataTable Especificar o título da Coluna e o tamanho */ DataGridColumnStyle boolCol = new DataGridTextBoxColumn();boolCol.MappingName = “Current”;boolCol.HeaderText = “IsCurrent Customer”;boolCol.Width = 150;ts1.GridColumnStyles.Add(boolCol);

// Uma nova colunaDataGridColumnStyle TextCol = new DataGridTextBoxColumn();TextCol.MappingName = “CustName”;TextCol.HeaderText = “Customer Name”;TextCol.Width = 250;ts1.GridColumnStyles.Add(boolCol);

//Associar o datagrigTableStyle ao GridTablestylesCollection.DataGrid1.TableStryles.Add(ts1);

Documents

C#NET