Anda di halaman 1dari 140

Projecto de Sistemas Industriais

C#.NET

ESTCB - IPCB
Departamento de Engenharia Informática
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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 2
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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 3
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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 4
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 5
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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 6
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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 7
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)

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 8
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 interface IFoo:IBar {…}

 Delegados delegate double MathFunc (double x);

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 9
C# - Tipos de Dados

CTS Type Name Tamanho .NET tipo Descrição


System.Object object Classe base para todos os tipos CTS
System.String string String
System.SByte 1 sbyte 8 bits com sinal (-128 até 127)
System.Byte 1 byte 8bits sem sinal (0 até 255)
System.Int16 2 short 16 bits com sinal (-32,768 até 32767)
System.UInt16 2 ushort 16 bits sem sinal (0 até 65,535)
System.Int32 4 int 32 bits com sinal (-2,147,483,648 até 2,147,483,648)
System.UInt32 4 uint 32 bits sem sinal (0 até 4,294,967,295)
System.Int64 8 long 64 bits com sinal (-9,223,372,036,854,775,808 até
9,223,372,036,854,775,807)
System.UInt64 8 ulong 64 bits sem sinal (0 até 0xFFFFFFFFFFFFFFFF)
System.Char 2 char Caracteres
System.Single 4 Float Numeros de virgula Flutuante
System.Double 8 Double Virgula flutuante de dupla precisão
System.Boolean 1 bool True ou False
System.Decimal 16 decimal Até 28 dígitos, normalmente utilizado em aplicações financeiras

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 10
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 11
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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 12
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
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 13
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 14
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 Teste


int x;
double d;
Currency balance;
#endregion

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 15
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 16
C# - Documentação XML
TAG Descrição
<c> Especifica uma linha como sendo uma linha de código

<code> Especifica várias linhas como sendo código

<example> Especifica como sendo código exemplo

<exception> Documenta uma excepção

<include> Inclui comentários de outro ficheiro de documentação

<list> Permite inserir uma lista dentro da documentação

<param> Especifica 1 parâmetro do método.

<paramref> Especifica que uma palavra é parâmetro do método.

<permission> Documenta o acesso a um membro.

<remarks> Adiciona uma descrição a um método.

<returns> Documenta o valor de retorno do método.

<see> Fornece uma referência cruzada a um outro parâmetro.

<seealso> Permite especificar um “ver também”.

<sumary> Permite especificar um breve sumário.

<value> Descreve uma propriedade

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 17
C# - Documentação XML

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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 18
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,

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

 Incrementos e Decrementos,

 Relacionais,

 Lógicos em operações condicionais.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 19
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.
Operador Descrição
++ Incrementa um valor
-- Decrementa um valor
+= Soma o valor à variável em questão
-= Subtrai o valor à variável em questão
*= Multiplica o valor à variável em questão
/= Divide o valor à variável em questão

myExample = 10;

myExample ++; // myExample = 11

myExample += 9 // myExample = 20

myExample /= 5 // myExample = 4

myExample *= 10 // myExample = 40

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 20
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?

Sufixo

secondvalue = 10;

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

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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 21
C# - Operadores
 Operadores relacionais são utilizados para comparar dois valores, retorna como
resultado um valor booleano.

Descrição Operador Expressão Resultado


Igualdade == bigvalue == 100 true
bigvalue == 80 false
Diferente != bigvalue != 100 false
bigvalue != 80 true
Maior que > bigvalue > smallvalue true
Maior ou igual que >= bigvalue >= smallvalue false
smallvalue >= bigvalue false
Menor que < bigvalue < smallvalue false
Menor ou igual que <= bigvalue <= smallvalue true
smallvalue <= bigvalue false

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

bigvalue = 100 e smallvalue = 50

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 22
C# - Operadores

Lógicos

Descrição Operador Expressão Resultado


and && (x==3) && (y == 7) false
or || (x==3) || (y == 7) true
not ! ! (x==3) true

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

x=5ey=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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 23
C# - Operadores
IS

 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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 24
C# - Operadores

Precedência

Descrição Operadores
Primário () . x++ x– new typeof sizeof checked unchecked
Unários + - ! ~ ++x –-x
Multiplicação/Divisão * / %
Adição/subtracção + -
Deslocamento de bits << >>
Relacionais < > <= >= is as
Comparação == !=
AND &
XOR ^
OR |
Boolean AND &&
Boolean OR ||
Ternário ?:
Atribuição = += -= *= /= %= &= |= ^= <<= >>=

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 25
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”);

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 26
C# - Estruturas de Decisão

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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 27
C# - Estruturas de Decisão

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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 28
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 true
DoSomeWork();
condition = checkCondition(); // assume checkCondition() retorna um bool
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 29
C# - Estruturas de Ciclo

 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 vez
DoSomeWork();
condition = checkCondition(); // assume checkCondition() retorna um bool
} while (condition)

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 30
C# - Estruturas de Ciclo

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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 31
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 32
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 33
C# - Excepções - throw
namespace MyThrow
{
using System;
public class Test
{
OUTPUT:
public static void Main()
{
Enter Main…
Console.WriteLine("Enter Main...");
Enter Func1…
Test t = new Test();
Enter Func2…
t.Func1();
Console.WriteLine("Exit Main...");
Exception ocurred: System.Execption: Na
} exception of type System.Exception was
public void Func1() throw.
{
Console.WriteLine("Enter Func1..."); at MyThrow.Test.Func2();
Func2(); in …exception01.css:line 23
Console.WriteLine("Exit Func1...");
} at MyThrow.Test.Func1();
public void Func2() in …exception01.css:line 17
{
Console.WriteLine("Enter Func2..."); at MyThrow.Test.Main();
throw new System.Exception(); in …exception01.css:line 11
Console.WriteLine("Exit Func2...");
}
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 34
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(); OUTPUT:
Console.WriteLine("Exit Main...");
}
Enter Main…
public void Func1() {
Enter Func1…
Console.WriteLine("Enter Func1...");
Func2(); Enter Func2…
Console.WriteLine("Exit Func1..."); Entering try Block
} Exception caught and handled.
Exit Func2…
public void Func2() { Exit Func1…
try { Exit Main…
Console.WriteLine("Enter Func2...");
throw new System.Exception();
Console.WriteLine("Exit try Block...");
}
catch
{
Console.WriteLine("Exception caught and handled");
}
Console.WriteLine("Exit Func2...");
}
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 35
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...");
}
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 36
C# - Excepções – catch dedicados
namespace MyDedicatedCatch
{
using System;
public class DedicatedCatch
{
public static void Main()
{
DedicatedCatch t = new DedicatedCatch();
t.TestFunc();
Console.ReadLine();
}

//do the division if legal


public double DoDivide(double num1, double num2)
{
if (num2==0)
throw new System.DivideByZeroException();
if (num1==0)
throw new System.ArithmeticException();

return num1/num2;
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 37
C# - Excepções – catch dedicados 2

// Try to divide 2 numbers handle possible excaptions


public 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 last
catch {
Console.WriteLine("Unknow exception caucht!");
}
}
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 38
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 39
C# - Excepções – finally
namespace MyDedicatedCatch
{
using System;
public class DedicatedCatch
{
public static void Main()
{
DedicatedCatch t = new DedicatedCatch();
t.TestFunc();
Console.ReadLine();
}

//do the division if legal


public double DoDivide(double num1, double num2)
{
if (num2==0)
throw new System.DivideByZeroException();
if (num1==0)
throw new System.ArithmeticException();

return num1/num2;
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 40
C# - Excepções – finally 2

// Try to divide 2 numbers handle possible excaptions


public void TestFunc()
{
try{
Console.WriteLine("Open the file here.");
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!");
}
//generic exception type last
catch {
Console.WriteLine("Unknow exception caucht!");
}
finally
{
Console.WriteLine("Close the file here.");
}
}
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 41
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 42
C# - Objecto Excepção
namespace MyDedicatedCatch
{
using System;
public class DedicatedCatch
{
public static void Main()
{
DedicatedCatch t = new DedicatedCatch();
t.TestFunc();
Console.ReadLine();
}
//do the division if legal
public 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;
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 43
C# - Objecto Excepção 2
// Try to divide 2 numbers handle possible excaptions
public void TestFunc()
{
try {
Console.WriteLine("Open the file here.");
double a = 5;
double b = 0;
Console.WriteLine("{0}/{1} = {2}", a,b,DoDivide(a,b));
}
//most derived exception type first
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 last
catch {
Console.WriteLine("Unknow exception caucht!");
}
finally
{
Console.WriteLine("Close the file here.");
}
}
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 44
C# - Objecto Excepção 3

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 45
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}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 46
C# - Classes e Objectos

 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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 47
C# - Classes e Objectos

 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.

Access-modifiers Restrições

public Sem restrições, membros definidos como public são visíveis a


qualquer método de qualquer classe.
private Membros na classe A definidos como private são acessíveis
unicamente a métodos desta classe.
protected 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.
internal Membros na classe A definidos como internal são acessíveis
unicamente a métodos da classe A durante a assemblagem.
protected internal 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.
ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 48
C# - Classes e Objectos

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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 49
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.

Tipo Valor por defeito

numeric (int, long, etc) 0

bool False

char ‘\0’ (null)

enum 0

reference null

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 50
C# - Classes – Construtor
public class Time
{
//private member variables
int Year;
int Month;
int Date;
int Hour;
int Minute;
int Second;

// public acessor Methods


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

//constructor
public Time(System.DateTime dt)
{
Year = dt.Year;
Month = dt.Month;
Date = dt.Day;
Hour = dt.Hour;
Minute = dt.Minute;
Second = dt.Second;
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 51
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();
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 52
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:

public void SomeMethod (int Hour)


{
this.Hour = Hour;
}

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

public void FirstMethod (OtherClass otherObject)


{
otherObject.SecondMethod(this);
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 53
C# - Classes – Copy

 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.

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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 54
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 55
C# - Membros Estáticos

 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)

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 56
C# - Membros Estáticos
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();
}
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 57
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).

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 58
C# - Passagem de Parâmetros
namespace MyConstrutor
{
public class Time
{
//private member variables
int Year;
int Month;
int Date;
int Hour;
int Minute;
int Second;

// public acessor Methods


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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 59
C# - Passagem de Parâmetros 2
//constructor
public 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();
}
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 60
C# - Passagem de Parâmetros

 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.

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


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

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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 61
C# - Passagem de Parâmetros

 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)


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

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

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 62
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.

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 63
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;
}
}

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 64
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;

ESTCB - IPCB
Departamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 65
Projecto de Sistemas Industriais

C#.NET
Parte II

ESTCB - IPCB
Departamento de Engenharia Informática
Sumário – C#.NET

 Estruturas

 Operador Overloading

 Interfaces

 Vectores e Classe Collections

Exemplos retirados do livro:


Programming C#, Jesse Liberty – O’Reilly

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 2


Departamento de Engenharia Informática
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};

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 3


Departamento de Engenharia Informática
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;
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 4


Departamento de Engenharia Informática
C# - Estruturas

public int y
{
get
{
return yVal;
}
set
{
yVal = value;
}
}

public override string ToString()


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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 5


Departamento de Engenharia Informática
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);
}
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 6


Departamento de Engenharia Informática
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.

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 7


Departamento de Engenharia Informática
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.

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 8


Departamento de Engenharia Informática
C# - Operador Overloading

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)

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 9


Departamento de Engenharia Informática
C# - Operador Overloading

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.

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 10


Departamento de Engenharia Informática
C# - Operador Overloading

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 // implicita
myInt = (int) myLong // explícita

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 11


Departamento de Engenharia Informática
C# - Operador Overloading

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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 12


Departamento de Engenharia Informática
C# - Operador Overloading

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 diferentes
return false;
}

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


{
return !(lhs==rhs);
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 13


Departamento de Engenharia Informática
C# - Operador Overloading

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/8
int 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;
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 14


Departamento de Engenharia Informática
C# - Operador Overloading

public class Tester


{

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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 15


Departamento de Engenharia Informática
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]
ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 16
Departamento de Engenharia Informática
C# - Interfaces

namespace MyInterface
{
using System;
// declare the interface
interface IStorable
{
// no access modifiers, methods are public
// no implementation
void Read( );
void Write(object obj);
int Status { get; set; }

}
// Take our interface out for a spin
public class Tester
{

static void Main( )


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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 17


Departamento de Engenharia Informática
C# - Interfaces
// create a class which implements the IStorable interface
public class Document : IStorable
{
public Document(string s){
Console.WriteLine("Creating document with: {0}", s);
}
// implement the Read method
public void Read( ){
Console.WriteLine(
"Implementing the Read Method for IStorable");
}
// implement the Write method
public void Write(object o){
Console.WriteLine(
"Implementing the Write Method for IStorable");
}
// implement the property
public int Status{
get {
return status;
}
set{
status = value;
}
}
// store the value for the property
private int status = 0;
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 18


Departamento de Engenharia Informática
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.

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 19


Departamento de Engenharia Informática
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.

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 20


Departamento de Engenharia Informática
C# - Interfaces

namespace MyInterfaceCombining
{
using System;
interface IStorable {
void Read();
void Write(object obj);
int Status { get; set; }

}
// here's the new interface
interface ICompressible {
void Compress();
void Decompress();
}
// Extend the interface
interface ILoggedCompressible : ICompressible {
void LogSavedBytes();
}
// Combine Interfaces
interface IStorableCompressible : IStorable, ILoggedCompressible {
void LogOriginalSize();
}
// yet another interface
interface IEncryptable {
void Encrypt();
void Decrypt();
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 21


Departamento de Engenharia Informática
C# - Interfaces

public class Document : IStorableCompressible, IEncryptable


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

}
// implement IStorable
public 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;
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 22


Departamento de Engenharia Informática
C# - Interfaces

// implement ICompressible
public void Compress() {
Console.WriteLine("Implementing Compress");
}
public void Decompress() {
Console.WriteLine("Implementing Decompress");
}
// implement ILoggedCompressible
public void LogSavedBytes() {
Console.WriteLine("Implementing LogSavedBytes");
}
// implement IStorableCompressible
public void LogOriginalSize() {
Console.WriteLine("Implementing LogOriginalSize");
}
// implement IEncryptable
public void Encrypt() {
Console.WriteLine("Implementing Encrypt");

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

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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 23


Departamento de Engenharia Informática
C# - Interfaces

public class Tester


{
static void Main()
{
// create a document object
Document doc = new Document("Test Document");

// cast the document to the various interfaces


IStorable 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");

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 24


Departamento de Engenharia Informática
C# - Interfaces

IStorableCompressible isc = doc as IStorableCompressible;


if (isc != null)
{
isc.LogOriginalSize(); // IStorableCompressible
isc.LogSavedBytes(); // ILoggedCompressible
isc.Compress(); // ICompressible
isc.Read(); // IStorable

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

IEncryptable ie = doc as IEncryptable;


if (ie != null)
{
ie.Encrypt();
}
else
Console.WriteLine("Encryptable not supported");
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 25


Departamento de Engenharia Informática
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
interface com o mesmo nome.
IStorable{

void Write();

void Read()

interface ITalk{

void Talk();

void Read()
v
}oid ITalk.Read()
{

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

}
ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 26
Departamento de Engenharia Informática
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.

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 27


Departamento de Engenharia Informática
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.

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 28


Departamento de Engenharia Informática
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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 29


Departamento de Engenharia Informática
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();
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 30


Departamento de Engenharia Informática
C# - Vectores
public class Tester
{

static void Main()


{
int[] intArray;
Employee[] empArray;
intArray = new int[5];
empArray = new Employee[3];

//populate the array


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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 31


Departamento de Engenharia Informática
C# - Vectores - foreach
public class Tester
{

static void Main()


{
int[] intArray;
Employee[] empArray;
intArray = new int[5];
empArray = new Employee[3];

//populate the array


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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 32


Departamento de Engenharia Informática
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);
}
}
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 33


Departamento de Engenharia Informática
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}};


ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 34
Departamento de Engenharia Informática
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][];

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 35


Departamento de Engenharia Informática
C# - Vectores - jagged

namespace MyJaggedArray
{
using System;

public class Tester


{
static void Main()
{
const int rows = 4;

// declare the jagged array as 4 rows high


int[][] jaggedArray = new int[rows][];

// the first row has 5 elements


jaggedArray[0] = new int[5];

// a row with 2 elements


jaggedArray[1] = new int[2];

// a row with 3 elements


jaggedArray[2] = new int[3];

// the last row has 5 elements


jaggedArray[3] = new int[5];

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 36


Departamento de Engenharia Informática
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 < 2; i++){


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

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


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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 37


Departamento de Engenharia Informática
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.

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 38


Departamento de Engenharia Informática
C# - Vectores - ArrayList
namespace MyArrayList
{
using System;
using System.Collections;
// a simple class to store in the array
public 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;
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 39


Departamento de Engenharia Informática
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.


ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 40
Departamento de Engenharia Informática
C# - Vectores - hashtables

namespace MyHash
{
using System;
using System.Collections;

public class Tester


{
static void Main( )
{
// 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 item


Console.WriteLine("myHashTable[\"000145938\"]: {0}",
hashTable["000145938"]);
}
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 41


Departamento de Engenharia Informática
C# - Vectores - hashtables
namespace MyHashProperties
{
using System;
using System.Collections;
public class Tester
{
static void Main( )
{
// 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 hashTable


ICollection keys = hashTable.Keys;
// get the values
ICollection values = hashTable.Values;
// iterate over the keys ICollection
foreach(string key in keys){
Console.WriteLine("{0} ", key);
}
// iterate over the values collection
foreach (string val in values){
Console.WriteLine("{0} ", val);
}
}
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 42


Departamento de Engenharia Informática
C# - Vectores - IDictionaryEnumerator
namespace MyDictionaryEnumerator
{
using System;
using System.Collections;
public class Tester
{
static void Main( )
{
// 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( );
}
}
}

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 43


Departamento de Engenharia Informática
C# - Vectores

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


seguintes:

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves – 2006/07 44


Departamento de Engenharia Informática
Projecto de Sistemas Industriais

C#.NET
Parte III

ESTCB - IPCB
Departamento de Engenharia Informática
Sumário – C#.NET

 ADO.NET

 DataSet

 DataTable

 DataColumn

 DataRow

 DataGrid

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 2


Departamento de Engenharia Informática
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

ESTCB

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

Projecto de Sistemas Industriais, Carlos Alves - 2006/07 3


Departamento de Engenharia Informática
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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 4


Departamento de Engenharia Informática
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
ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 5
Departamento de Engenharia Informática
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;

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 6


Departamento de Engenharia Informática
C# - ADO.NET

1. Abrir ligação

SqlConnection 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 comando
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = "SELECT cod, descricao FROM detalhes WHERE zona=42 “;
SqlDataReader reader = cmd.ExecuteReader();

3. Processar linhas no reader


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

4. Fechar reader
if(!reader.IsClosed)
reader.Close();
ESTCB - IPCB 7
5.Departamento
Fechar ligação
de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07
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;

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 8


Departamento de Engenharia Informática
C# - ADO.NET

1. Abrir a ligação
SqlConnection conn = new SqlConnection("SERVER=SQLSERVER; INTEGRATED SECURITY = TRUE; INITIAL
CATALOG=ISEP");
conn.open();
2. Preencher o DataSet
System.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ção
conn.Close() ;
4. Processar o DataSet
foreach(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ção
conn.Close() ;

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 9


Departamento de Engenharia Informática
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;

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 10


Departamento de Engenharia Informática
C# - ADO.NET

Executar comandos que retornem um só registo

// 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ção
conn.Open();
//Definir um novo comando do tipo OLEDB
OleDbCommand cmd = new OleDbCommand();
//Colocar o texto do comando
cmd.CommandText = "SELECT NOME FROM PESSOA WHERE NUMERO = ?“;
//Indicar ao comando qual é a ligação que vai usar
cmd.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 texto
txtNome.Text = cmd.ExecuteScalar() .ToString();
//Fechar a ligação
conn.Close();

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 11


Departamento de Engenharia Informática
C# - ADO.NET

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


registos)
//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ção
conn.Open();
//Definir um novo comando do tipo OLEDB
OleDbCommand cmd = new OleDbCommand();
//Colocar o texto do comando
cmd.CommandText = "INSERT INTO TRABALHOS VALUES(?, ?)";
//Indicar ao comando qual é a ligação que vai usar
cmd.Connection = conn;
//Definir os parametros para inserir os valores
OleDbParameter parmNumero = cmd.Parameters.Add(new OleDbParameter("@Numero", OleDbType.Integer));
OleDbParameter parmNome = cmd.Parameters.Add(new OleDbParameter("@Nome", OleDbType.Char)) ;
// Inserir os valores
for(int i=O; i<cmbNomes.Items.Count; i++)
{
parmNumero.Value = i+l;
parmNome.Value = cmbNomes.Items[i];
//Executar o comando para inserir os valores
cmd.ExecuteNonQuery();
}
//Fechar a ligação
conn.Close();

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 12


Departamento de Engenharia Informática
C# - ADO.NET

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

//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ção
conn.Open() ;
//Definir um novo comando do tipo OLEDB
OleDbCommand cmd = new OleDbCommand();
//Colocar o texto do comando
cmd.CommandText = "SELECT NOME FROM PESSOA";
//Indicar ao comando qual é a ligação que vai usar
cmd.Connection = conn;
//Definir um DataReader para ler os dados
//DataReader = forward only, read only. Muito rápido.
//Executar o comando e associá-lo ao reader
OleDbDataReader reader = cmd.ExecuteReader();
//Percorrer o reader e colocar os valores
while(reader.Read())
cmbNomes.Items.Add(reader[O] .ToString());
//Se o reader não estiver fechado, fechar...
if( !reader.IsClosed )
reader.Close();
//Fechar a ligação
conn.Close() ;

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 13


Departamento de Engenharia Informática
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.

Dataset() Cria um Dataset


Construtores
Dataset(string Nome) Cria um Dataset, com um determinado nome

Dataset(SerializationInfom usado pelo .Net. Não é para ser utilizado directamente


StreamingContext)

MergeFailed Ocorre quando o método Merge falha

Eventos
ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 14
Departamento de Engenharia Informática
C# - DataSet
Propriedades
CaseSensitive Controla se as comparações de strings são ou não sensíveis a Maiúsculas / Minusculas

DatasetName Nome do Dataset

DesignMode Indica se o Dataset está ou não em modo Design

EnforceConstraints Controla se o Dataset vai ou não forçar constraints

ExtendedProperties Colecção de propriedades dinâmicas

Locale Definições de linguagens, usadas para comparar strings

HasErrors Indica se o Dataset tem ou não erros

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

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

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

Tables Colecção de tabelas. Contém objectos DataTable

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 15


Departamento de Engenharia Informática
C# - DataSet
Métodos
AcceptChanges– Aceita / Rejeita todas as alterações pendentes Dentro do Dataset. Funciona com um Commit /
RejectChanges Rollback local. Aceita todas as alterações pendentes Dentro do Dataset. Funciona com um
Commit local.
BeginInit e EndInit Usado internamente pelo Visual Studio .Net, antes e depois de adicionar informação sobre o
Schema do Dataset

Clear Apaga todos os DataTable’s do Dataset

Clone Cria um novo Dataset com o mesmo schema, mas sem dados

Copy Novo Dataset com o mesmo schema e com os mesmos dados

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

GetXml Devolve os dados do Dataset em XML (string)

GetXmlSchema Devolve o schema do Dataset em XML (string)

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

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

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

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

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

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

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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 16


Departamento de Engenharia Informática
C# - DataSet

Criar um DataSet programaticamente


//Definir um DataSet chamado "AULAS"
DataSet dsAulas = new DataSet("AULAS");
//Definir as DataTable
DataTable dtAlunos;
DataTable dtInscricoes;
//Dizer que as tabelas pertencem ao DataSet
dtAlunos = dsAulas.Tables.Add("ALUNOS");
dtInscricoes = dsAulas.Tables.Add("INSCRICOES");
//Definir a estrutura das tabelas
dtAlunos.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", new
DataColumn[] {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["NUMER
O_ALUNO"]);
//Mostrar o DataSet numa grelha
dgAulas.DataSource = dsAulas;
//Mostrar uma tabela especifica do DataSet
dgAulas.DataMember = "ALUNOS";

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 17


Departamento de Engenharia Informática
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 Adapter
serve 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


ESTCB
objectos
- IPCB Data Table e Data Projecto
Relation.
de Sistemas Industriais, Carlos Alves - 2006/07 18
Departamento de Engenharia Informática
C# - DataSet

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 19


Departamento de Engenharia Informática
C# - DataSet
 Um objecto Data Table consiste de um ou mais objectos Data Column, Data Row
e Constraint.

 Um objecto Data Relation define o modo como as tabelas de um objecto Dataset


estã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.
ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 20
Departamento de Engenharia Informática
C# - DataTable
Construtores
DataTable() Cria um novo DataTable

DataTable(nome) Cria um novo DataTable com um determinado nome

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


StreamingContext)

Eventos
ColumnChanged – Depois do conteúdo de uma coluna ser alterado

ColumnChanging Antes do conteúdo de uma coluna ser alterado

RowChanged Depois do conteúdo de uma linha ser alterado

RowChanging Antes do conteúdo de uma linha ser alterado

RowDeleted Depois de uma linha ser apagada

RowDeleting Antes de uma linha ser apagada

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 21


Departamento de Engenharia Informática
C# - DataTable
Propriedades
CaseSensitive Controla se é ou não sensível a maiusculas/minu.
ChildRelations Colecção com DataRelations, que contêm dados dependentes
Columns Colecção de colunas (DataColumn)
Constraints Colecção de constraints

DataSet Dataset onde o DataTable está (null se não estiver associado a nenhums dataset)
DefaultView DataView por defeito
DesignMode Indica se o DataTable está em modo design
ExtendedProperties Colecção de propriedades dinâmicas
HasErrors Indica se há algum erro na tabela

Locale Definições de linguagens, usadas para comparar strings


MinimumCapacity Quantidade (em linhas-rows) de memória que o DataTable reserva inicialmente
Namespace Nome do namespace usado quando o DataTable grava ou carrega os dados para o XML
Prefix Prefixo do namespace usado quando o DataTable grava ou carrega os dados para o XML
ParentRelations Colecção com DataRelations, que contêm dados “pai”
PrimaryKey Array de DataColumns com a chave primária
Rows Colecção de linhas (DataRow) da tabela
TableName Nome da DataTable

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 22


Departamento de Engenharia Informática
C# - DataTable
Métodos
AcceptChanges – – Aceita/rejeita todas as alterações pendentes da tabela (como commit/rollback para dados locais)
RejectChanges
BeginInit – EndInit Usado internamente pelo Visual Studio .Net, antes e depois de adicionar informação sobre o Schema do Dataset

BeginLoadData – Desliga e volta a ligar as constraints. Util para carregar dados


EndLoadData
Clear Apaga todas as linhas do DataTable
Clone Cria um novo DataTable, com o mesmo schema, mas sem dados
Copy Cria um novo DataTable, com o mesmo schema e mesmo dados
Compute Devolve o valor de uma expressão agregada (ex: sum, max,...), baseado no conteudo do DataTable
GetChanges Cria um novo DataTable com o mesmo schema, mas apenas com as linhas que foram modificadas do DataTable
original

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


ImportRow Importa uma linha já existente para o DataTable
LoadDataRow Adiciona uma linha ao DataTable, passando os valores dessa linha através de um array
NewRow Cria e devolve uma nova linha do DataTable (vazia)
Reset Faz um reset ao DataTable, de forma a que fique com estado original do DataTable
Select Devolve um array de DataRows, baseado num determinado critério de pesquisa

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 23


Departamento de Engenharia Informática
C# - DataColumn
Propriedades
AllowDBNull – Controla se a coluna aceita ou não NULLs

AutoIncrement Controla se a coluna gere valores autoincrement

AutoIncrementSeed 1º valor do autoincrement


AutoIncrementStep controla quanto o autoincrementa salta

Caption Titulo da coluna quando numa grelha


ColumnMapping Controla como o ADO.Net armazena o conteudo da coluna em XML

ColumnName Nome do objecto DataColumn

DataType Controla o tipo de dados armazenado pela coluna


DefaultValue Controla o valor por defeito para esta coluna, quando são criadas novas
Expression linhasControla como o ADO.Net calcula o valor da coluna (para colunas baseadas em expressões)

ExtendedProperties Colecção de propriedades dinâmicas

MaxLength Tamanho máximo das colunas string

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

Prefix Prefixo do namespace usado grava ou carrega os dados para o XML

Ordinal Indice da coluna na colecção de colunas do DataTable

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

Table DataTable a que pertence a coluna

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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 24


Departamento de Engenharia Informática
C# - DataRow

Propriedades

HasErrors- Indica se a linha tem ou não erros

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

ItemArray Acesso aos valores da linha, usando um array de objectos

RowError Informação sobre o erro associada à linha

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

Table Tabela a que pertence o DataRow

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 25


Departamento de Engenharia Informática
C# - DataRow
Métodos
AcceptChanges – Aceita ou Rejeita as alterações da linha.
RejectChanges

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

ClearErrors Limpa os erros associados à linha

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

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

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

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

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

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

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

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

SetColumnError Alterar a informação de erro de uma determinada coluna

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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 26


Departamento de Engenharia Informática
C# - Exemplos

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

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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 27


Departamento de Engenharia Informática
C# - Exemplos
Select- Método da DataTable, que devolve um array de linhas, baseado num
determinado critério.
DataRow[] Linhas = Tabela.Select(“(Pais=’PT’) and (cidade <> ‘Leiria’)”);

...

Exemplos de Expressões no Select

xpto LIKE ‘%a’ - xpto acaba em a


xpto LIKE ‘a%’ – xpto começa por a
xpto = ‘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 Select

DataRow[] 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.Deleted
DataRow[] Linhas = Tabela.Select(“”, “”, Estado);
//Devolve as linhas que foram modificadas ou apagadas.

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 28


Departamento de Engenharia Informática
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 DataTable
DataTable myDataTable = myDataSet.Tables[“Customers”];
dataGrid1.DataSource = myDataTable;

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 29


Departamento de Engenharia Informática
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,5


mydataGrid1.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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 30


Departamento de Engenharia Informática
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 coluna


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

ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 31


Departamento de Engenharia Informática