ESTCB - IPCBDepartamento de Engenharia Informática
Projecto de Sistemas Industriais
C#.NET
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 2
Sumário – C#.NET
Variáveis
Documentação XML
C# Preprocessor Directives
Operadores
Estruturas de Decisão
Estruturas de Ciclo
Erros e Excepções
Classes e Objectos
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 3
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 4
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 5
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 6
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 7
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 8
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 9
C# - Tipos de Dados
Tipos Valor
Primitivos int i;
Enumerações enum State {On, OFF}
Estruturas struct Point {int x,y;}
Tipos Referência
Arrays string[] a = new string[10];
Classes class Foo:Bar,IFoo {…}
Interfaces interfaceIFoo:IBar {…}
Delegados delegate double MathFunc (double x);
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 10
C# - Tipos de Dados
Até 28 dígitos, normalmente utilizado em aplicações financeirasdecimal16System.Decimal
True ou Falsebool1System.Boolean
Virgula flutuante de dupla precisãoDouble8System.Double
Numeros de virgula FlutuanteFloat4System.Single
Caractereschar2System.Char
64 bits sem sinal (0 até 0xFFFFFFFFFFFFFFFF)ulong8System.UInt64
64 bits com sinal (-9,223,372,036,854,775,808 até 9,223,372,036,854,775,807)
long8System.Int64
32 bits sem sinal (0 até 4,294,967,295)uint4System.UInt32
32 bits com sinal (-2,147,483,648 até 2,147,483,648)int4System.Int32
16 bits sem sinal (0 até 65,535)ushort2System.UInt16
16 bits com sinal (-32,768 até 32767)short2System.Int16
8bits sem sinal (0 até 255)byte1System.Byte
8 bits com sinal (-128 até 127)sbyte1System.SByte
StringstringSystem.String
Classe base para todos os tipos CTSobjectSystem.Object
Descrição.NET tipoTamanhoCTS Type Name
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 11
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 12
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 13
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 14
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 15
C# - Preprocessor Directives
As directivas #region - #endregion, são usadas para indicar o inicio e o fim de
um determinado bloco de código.
#region Funções de Testeint x;double d;Currency balance;
#endregion
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 16
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 17
C# - Documentação XML
Especifica uma linha como sendo uma linha de código<c>Especifica várias linhas como sendo código<code>Especifica como sendo código exemplo<example>Documenta uma excepção<exception>Inclui comentários de outro ficheiro de documentação<include>Permite inserir uma lista dentro da documentação<list>
Descreve uma propriedade<value>Permite especificar um breve sumário.<sumary>Permite especificar um “ver também”.<seealso>Fornece uma referência cruzada a um outro parâmetro.<see>Documenta o valor de retorno do método.<returns>Adiciona uma descrição a um método.<remarks>Documenta o acesso a um membro.<permission>Especifica que uma palavra é parâmetro do método.<paramref>Especifica 1 parâmetro do método.<param>
DescriçãoTAG
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 18
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 19
C# - Operadores
Um operador consiste num símbolo que obriga a linguagem C# a tomar uma
acção.
Existem diversos tipos de operadores:
Matemáticos,
Incrementos e Decrementos,
Relacionais,
Lógicos em operações condicionais.
Resto da divisão%Divisão/Multiplicação*Subtracção-Adição+
DescriçãoOperador
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 20
C# - Operadores
Uma operação comum em programação é a necessidade de somar ou subtrair a
uma variável, ou ainda, modificar o valor de uma variável, e atribui-lo novamente
à mesma variável.
Divide o valor à variável em questão/=Multiplica o valor à variável em questão*=Subtrai o valor à variável em questão-=Soma o valor à variável em questão+=Decrementa um valor--Incrementa um valor++
DescriçãoOperador
myExample = 10;myExample ++; // myExample = 11myExample += 9 // myExample = 20myExample /= 5 // myExample = 4myExample *= 10 // myExample = 40
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 21
C# - Operadores
Para complicar ainda mais as coisas, é possível incrementar uma variável e
atribuir esse valor a outra variável.
firstvalue = secondvalue ++;
Coloca-se uma questão com a atribuição anterior: o incremento é para ocorrer
antes ou depois da atribuição?
Sufixosecondvalue = 10;firstvalue = secondvalue++; // firstvalue = 10 // secondvalue = 11
Prefixosecondvalue = 10;firstvalue = ++secondvalue; // firstvalue = 11 // secondvalue = 11
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 22
C# - Operadores
Operadores relacionais são utilizados para comparar dois valores, retorna como
resultado um valor booleano.
falsesmallvalue <= bigvaluetruebigvalue <= smallvalue<=Menor ou igual quefalsebigvalue < smallvalue<Menor quefalsesmallvalue >= bigvalue
bigvalue >= smallvaluebigvalue > smallvaluebigvalue != 80bigvalue != 100bigvalue == 80bigvalue == 100
Expressão
>=>
!=
==Operador
falseMaior ou igual quetrueMaior quetruefalseDiferentefalsetrueIgualdade
ResultadoDescrição
Assume-se como valores iniciais para as variáveis:
bigvalue = 100 e smallvalue = 50
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 23
C# - Operadores
! (x==3)(x==3) || (y == 7)(x==3) && (y == 7)
Expressão
!||&&
Operador
truenottrueorfalseand
ResultadoDescrição
Assume-se como valores iniciais para as variáveis:
x = 5 e y = 7
typeof
O operador typeof retorna o tipo de dados do objecto em questão.
Isto torna-se útil quando se pretende usar reflexão de forma a obter informção
sobre objecto criados dinamicamente.
Lógicos
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 24
C# - OperadoresIS
O operador is permite avaliar se um determinado objecto é compatível com um
determinado tipo.
int i = 10;if (i is object){
Console.WriteLine(“i é um objecto”);}
AS
O operador as é utilizado em conversões explicitas de tipos de dados. Se o tipo
para o qual se pretende converter é compatível com o tipo de dados actual, a
conversão é executada, caso contrário é retornado o valor null.
object o1 = “some string”;object o2 = 5;
string s1 = o1 as string; // s1 = “some string”string s2 = o2 as string; // s2 = null
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 25
C# - Operadores
Precedência
= += -= *= /= %= &= |= ^= <<= >>=Atribuição?:Ternário||Boolean OR&&Boolean AND|OR^XOR&AND
== !=Comparação< > <= >= is as
<< >>+ - * / %
+ - ! ~ ++x –-x() . x++ x– new typeof sizeof checked unchecked
Operadores
RelacionaisDeslocamento de bitsAdição/subtracção
Multiplicação/DivisãoUnáriosPrimárioDescrição
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 26
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 27
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 28
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 29
C# - Estruturas de Ciclo
WHILE - É o comando de repetição mais simples. Testa uma condição e executa
um comando (ou conjunto de comandos) até a condição ser FALSE.
bool condition = false;while (!condition){
//fica dentro do ciclo até a condição ser trueDoSomeWork();condition = checkCondition();// assume checkCondition() retorna um bool
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 30
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 vezDoSomeWork();condition = checkCondition();// assume checkCondition() retorna um bool
} while (condition)
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 31
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 32
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 33
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 34
C# - Excepções - throw
namespace MyThrow{
using System;public class Test{
public static void Main(){
Console.WriteLine("Enter Main...");Test t = new Test();t.Func1();Console.WriteLine("Exit Main...");
}public void Func1(){
Console.WriteLine("Enter Func1...");Func2();Console.WriteLine("Exit Func1...");
}public void Func2(){
Console.WriteLine("Enter Func2...");throw new System.Exception();Console.WriteLine("Exit Func2...");
}}
}
OUTPUT:Enter Main…Enter Func1…Enter Func2…
Exception ocurred: System.Execption: Na exception of type System.Exception was throw.
at MyThrow.Test.Func2();in …exception01.css:line 23
at MyThrow.Test.Func1();in …exception01.css:line 17
at MyThrow.Test.Main();in …exception01.css:line 11
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 35
C# - Excepções - catch
namespace MyThrow { using System;
public class Test {
public static void Main() {Console.WriteLine("Enter Main...");Test t = new Test();t.Func1();Console.WriteLine("Exit Main...");
} public void Func1() {
Console.WriteLine("Enter Func1...");Func2();Console.WriteLine("Exit Func1...");
}
public void Func2() {try {
Console.WriteLine("Enter Func2..."); throw new System.Exception(); Console.WriteLine("Exit try Block...");}catch{ Console.WriteLine("Exception caught and handled");}
Console.WriteLine("Exit Func2..."); }}
}
OUTPUT:Enter Main…Enter Func1…Enter Func2…Entering try BlockException caught and handled.Exit Func2…Exit Func1…Exit Main…
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 36
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 37
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 legalpublic double DoDivide(double num1, double num2){
if (num2==0)throw new System.DivideByZeroException();
if (num1==0)throw new System.ArithmeticException();
return num1/num2;}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 38
C# - Excepções – catch dedicados 2
// Try to divide 2 numbers handle possible excaptionspublic void TestFunc(){
try{double a = 5;double b = 0;Console.WriteLine("{0}/{1} = {2}", a,b,DoDivide(a,b));
}//most derived exception type first
catch (System.DivideByZeroException){Console.WriteLine("DivideByZeroException caught!");
}catch (System.ArithmeticException){
Console.WriteLine("ArithmeticException caught!");}//generic exception type lastcatch {
Console.WriteLine("Unknow exception caucht!");}
}}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 39
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 40
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 legalpublic double DoDivide(double num1, double num2){
if (num2==0)throw new System.DivideByZeroException();
if (num1==0)throw new System.ArithmeticException();
return num1/num2;}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 41
C# - Excepções – finally 2
// Try to divide 2 numbers handle possible excaptionspublic 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 lastcatch {
Console.WriteLine("Unknow exception caucht!");}finally{ Console.WriteLine("Close the file here.");}
}}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 42
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 43
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 legalpublic double DoDivide(double num1, double num2){
if (num2==0){DivideByZeroException e = new DivideByZeroException();e.HelpLink = "http://www.libertyassociates.com";throw e;
}if (num1==0)
throw new System.ArithmeticException();return num1/num2;
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 44
C# - Objecto Excepção 2
// Try to divide 2 numbers handle possible excaptionspublic 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 lastcatch {
Console.WriteLine("Unknow exception caucht!");}finally{ Console.WriteLine("Close the file here.");}
}}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 45
C# - Objecto Excepção 3
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 46
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 47
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 48
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.
Membros na classe A definidos como protected internal são acessíveis a métodos da classe A e a métodos de classes derivadas desta durante a assemblagem. O conceito é protected OU internal.
protected internal
Membros na classe A definidos como internal são acessíveis unicamente a métodos da classe A durante a assemblagem.
internal
Membros na classe A definidos como protected são acessíveis a métodos da classe A e a métodos de classes derivadas desta.
protected
Membros na classe A definidos como private são acessíveis unicamente a métodos desta classe.
private
Sem restrições, membros definidos como public são visíveis a qualquer método de qualquer classe.
public
RestriçõesAccess-modifiers
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 49
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 50
C# - Classes - Construtor
O construtor de uma classe consiste no método que é invocado aquando a
instanciação de um objecto.
Pode ser omitido, e deixar o CLR fornecer um construtor por defeito.
O objectivo do construtor é criar um objecto do tipo da classe e colocá-lo num
estado válido.
nullreference
0enum
‘\0’ (null)char
Falsebool
0numeric (int, long, etc)
Valor por defeitoTipo
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 51
C# - Classes – Construtor
public class Time{
//private member variablesint Year;int Month;int Date;int Hour;int Minute;int Second;// public acessor Methodspublic void DisplayCurrentTime(){
System.Console.WriteLine("{0}/{1}/{2} {3}:{4}:{5}", Month, Date, Year, Hour, Minute, Second);
}
//constructorpublic Time(System.DateTime dt){
Year = dt.Year;Month = dt.Month;Date = dt.Day;Hour = dt.Hour;Minute = dt.Minute;Second = dt.Second;
}}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 52
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 53
C# - Classes - this
A palavra reservada this refere-se à instância actual de um objecto.
A referência this representa 1 ponteiro para todos os métodos não static da
classe.
Existem 3 formas de usar o this (só serão analisadas 2):
Para atribuição de valores a variáveis da classe:
De forma a permitir passar o objecto actual como parâmetro a outro método:
public void SomeMethod (int Hour){
this.Hour = Hour;}
public void FirstMethod (OtherClass otherObject){
otherObject.SecondMethod(this);}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 54
C# - Classes – Copy
public Time(Time existingTimeObject){
this.Year = existingTimeObject.Year;this.Month = existingTimeObject.Month;this.Date = existingTimeObject.Date;this.Hour = existingTimeObject.Hour;this.Minute = existingTimeObject.Minute;this.Second = existingTimeObject.Second;
}
O construtor copy cria um novo objecto através da copia do conteúdo das
variáveis de um objecto existente do mesmo tipo.
C# não fornece nenhum construtor copy, pelo que caso seja necessário, é preciso
implementá-lo.
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 55
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 56
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 57
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 58
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 59
C# - Passagem de Parâmetros
namespace MyConstrutor{
public class Time{
//private member variablesint Year;int Month;int Date;int Hour;int Minute;int Second;// public acessor Methodspublic void DisplayCurrentTime(){
System.Console.WriteLine("{0}/{1}/{2} {3}:{4}:{5}", Month, Date, Year, Hour, Minute, Second);
}
public int GetHour(){
return Hour;}
public void GetTime(ref int h,ref int m,ref int s){
h = Hour;m = Minute;s = Second;
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 60
C# - Passagem de Parâmetros 2
//constructorpublic Time(System.DateTime dt){
Year = dt.Year;Month = dt.Month;Date = dt.Day;Hour = dt.Hour;Minute = dt.Minute;Second = dt.Second;
}}public class Tester{
static void Main(){
System.DateTime currentTime = System.DateTime.Now;Time t = new Time(currentTime);t.DisplayCurrentTime();
int theHour = 0;int theMinute = 0;int theSecond = 0;t.GetTime(ref theHour,ref theMinute,ref theSecond);System.Console.WriteLine("Current time: {0}:{1}:{2}",
theHour, theMinute, theSecond);System.Console.ReadLine();
}}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 61
C# - Passagem de Parâmetros
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);
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.
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 62
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 63
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 64
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 65
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 - IPCBDepartamento de Engenharia Informática
Projecto de Sistemas Industriais
C#.NET
Parte II
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 2
Sumário – C#.NET
Estruturas
Operador Overloading
Interfaces
Vectores e Classe Collections
Exemplos retirados do livro:Programming C#, Jesse Liberty – O’Reilly
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 3
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 4
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 5
C# - Estruturas
public int y{
get{
return yVal;}set{
yVal = value;}
}
public override string ToString(){
return (String.Format("{0}, {1}", xVal, yVal));}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 6
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 7
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 8
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 9
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 10
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 11
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 // implicitamyInt = (int) myLong // explícita
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 12
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 13
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 diferentesreturn false;
}
public static bool operator != (Fraction lhs, Fraction rhs){
return !(lhs==rhs);}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 14
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/8int firstProduct = lhs.numerator * rhs.denominator;int secondProduct = lhs.denominator * rhs.numerator;return new Fraction (firstProduct+secondProduct, lhs.denominator*rhs.denominator);
}public override string ToString(){
string s = numerator.ToString() + "/"+denominator.ToString();return s;
}}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 15
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 16
C# - Interfaces
Uma interface consiste basicamente num contracto com o cliente de sobre o comportamento de uma determinada classe ou estrutura.
Quando uma classe implementa uma interface, isto significa, que essa classe garante que suporta todos os métodos, propriedades e eventos da referida interface.
Sintáticamente, uma interface é semelhante a uma clase que possui somente métodos abstractos.
A implementação de uma interface implica relações.
Um carro é um veículo, no entanto pode implementar a capacidade PodeSerCompradoComRecursoCredito.
[attributes] [access-modifier] interface interface-name [:base-list]
{interface-body}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 17
C# - Interfaces
namespace MyInterface{
using System;// declare the interfaceinterface IStorable{
// no access modifiers, methods are public// no implementationvoid Read( );void Write(object obj);int Status { get; set; }
}// Take our interface out for a spinpublic class Tester{
static void Main( ){
// access the methods in the Document objectDocument doc = new Document("Test Document");doc.Status = -1;doc.Read( );Console.WriteLine("Document Status: {0}", doc.Status);
}}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 18
C# - Interfaces
// create a class which implements the IStorable interfacepublic class Document : IStorable{
public Document(string s){Console.WriteLine("Creating document with: {0}", s);
}// implement the Read methodpublic void Read( ){
Console.WriteLine("Implementing the Read Method for IStorable");
}// implement the Write methodpublic void Write(object o){
Console.WriteLine("Implementing the Write Method for IStorable");
}// implement the propertypublic int Status{
get {return status;
}set{
status = value;}
}// store the value for the propertyprivate int status = 0;
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 19
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 20
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 21
C# - Interfaces
namespace MyInterfaceCombining{
using System;interface IStorable {
void Read();void Write(object obj);int Status { get; set; }
}// here's the new interfaceinterface ICompressible {
void Compress();void Decompress();
}// Extend the interfaceinterface ILoggedCompressible : ICompressible {
void LogSavedBytes();}// Combine Interfacesinterface IStorableCompressible : IStorable, ILoggedCompressible {
void LogOriginalSize();}// yet another interfaceinterface IEncryptable {
void Encrypt();void Decrypt();
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 22
C# - Interfaces
public class Document : IStorableCompressible, IEncryptable{
// the document constructorpublic Document(string s) {
Console.WriteLine("Creating document with: {0}", s);
} // implement IStorablepublic void Read(){
Console.WriteLine("Implementing the Read Method for IStorable"); }public void Write(object o){
Console.WriteLine("Implementing the Write Method for IStorable"); }public int Status{
get{return status;
}set{
status = value;}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 23
C# - Interfaces
// implement ICompressiblepublic void Compress() {
Console.WriteLine("Implementing Compress"); } public void Decompress() {
Console.WriteLine("Implementing Decompress"); }// implement ILoggedCompressiblepublic void LogSavedBytes() {
Console.WriteLine("Implementing LogSavedBytes");} // implement IStorableCompressible public void LogOriginalSize() {
Console.WriteLine("Implementing LogOriginalSize");}// implement IEncryptablepublic void Encrypt() {
Console.WriteLine("Implementing Encrypt");
}public void Decrypt() {
Console.WriteLine("Implementing Decrypt");
}// hold the data for IStorable's Status propertyprivate int status = 0;
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 24
C# - Interfaces
public class Tester{
static void Main(){
// create a document objectDocument doc = new Document("Test Document");// cast the document to the various interfacesIStorable isDoc = doc as IStorable;if (isDoc != null){
isDoc.Read();}else
Console.WriteLine("IStorable not supported");
ICompressible icDoc = doc as ICompressible;if (icDoc != null){
icDoc.Compress();}else
Console.WriteLine("Compressible not supported");
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 25
C# - Interfaces
IStorableCompressible isc = doc as IStorableCompressible;if (isc != null){
isc.LogOriginalSize(); // IStorableCompressibleisc.LogSavedBytes(); // ILoggedCompressibleisc.Compress(); // ICompressibleisc.Read(); // IStorable
}else{
Console.WriteLine("StorableCompressible not supported");}
IEncryptable ie = doc as IEncryptable;if (ie != null){
ie.Encrypt();}else
Console.WriteLine("Encryptable not supported");}
}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 26
C# - Interfaces
Implementação explícita de uma Interface.
A implementação explícita torna-se necessário quando uma classe implementa duas interfaces que contêm pelo menos um método com o mesmo nome.interface IStorable{
void Write();void Read()
}
interface ITalk{void Talk();void Read()
}void ITalk.Read()
{Console.WriteLine(″Implementig ITalk.Read″);
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 27
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 28
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 29
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 30
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 31
C# - Vectores
public class Tester {
static void Main(){
int[] intArray;Employee[] empArray;intArray = new int[5];empArray = new Employee[3];//populate the arrayfor (int i = 0; i<empArray.Length;i++){
empArray[i]= new Employee(i+5);}
for (int i = 0; i<intArray.Length;i++){
Console.WriteLine(intArray[i].ToString());}
for (int i = 0; i<empArray.Length;i++){
Console.WriteLine(empArray[i].ToString());}
}}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 32
C# - Vectores - foreach
public class Tester {
static void Main(){
int[] intArray;Employee[] empArray;intArray = new int[5];empArray = new Employee[3];//populate the arrayfor (int i = 0; i<empArray.Length;i++){
empArray[i]= new Employee(i+5);}
foreach (int i in intArray){
Console.WriteLine(intArray[i].ToString());}
foreach (Employee e in empArray){
Console.WriteLine(e.ToString());}
}}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 33
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 34
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 35
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 36
C# - Vectores - jagged
namespace MyJaggedArray{
using System;
public class Tester{
static void Main(){
const int rows = 4;// declare the jagged array as 4 rows highint[][] jaggedArray = new int[rows][];// the first row has 5 elementsjaggedArray[0] = new int[5]; // a row with 2 elementsjaggedArray[1] = new int[2]; // a row with 3 elementsjaggedArray[2] = new int[3]; // the last row has 5 elementsjaggedArray[3] = new int[5];
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 37
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 38
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 39
C# - Vectores - ArrayList
namespace MyArrayList{
using System;using System.Collections;// a simple class to store in the arraypublic class Employee{
public Employee(int empID){
this.empID = empID;}public override string ToString(){
return empID.ToString();}public int EmpID{
get{
return empID;}set{
empID = value;}
}private int empID;
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 40
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 41
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 itemConsole.WriteLine("myHashTable[\"000145938\"]: {0}",
hashTable["000145938"]);}
}}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 42
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 hashTableICollection keys = hashTable.Keys;// get the valuesICollection values = hashTable.Values;// iterate over the keys ICollectionforeach(string key in keys){
Console.WriteLine("{0} ", key);}// iterate over the values collectionforeach (string val in values){
Console.WriteLine("{0} ", val);}
}}
}
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 43
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves – 2006/07 44
C# - Vectores
Para além dos vectores anteriormente referidos, existem ainda os
seguintes:
ESTCB - IPCBDepartamento de Engenharia Informática
Projecto de Sistemas Industriais
C#.NET
Parte III
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 2
Sumário – C#.NET
ADO.NET
DataSet
DataTable
DataColumn
DataRow
DataGrid
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 3
C# - ADO.NET
O ADO.NET fornece acesso consistente a fontes de dados, como por exemplo o SQL Server, assim como a outras fontes acessíveis via OLE
DB, XML ou ODBC.
As aplicações podem utilizar o ADO.NET para estabelecer ligações a bases de dados por forma a manipular os dados.
As classes para trabalhar com o ADO.NET estão no System.Data.xxxx, em que xxxx refere-se à especialização do fornecedor de acesso aos dados.
Deste forma, pode-se dizer que o ADO.NET é um conjunto de classes para trabalhar com dados.
Principais características: Um sucessor do ADO mais flexível
Um sistema desenhado para ambientes desconectados
Um modelo de programação com suporte avançado para XML
Um conjunto de classes, interfaces, estruturas e enumerações que gerem o acesso a dados dentro do framework
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 4
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 5
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 6
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 7
C# - ADO.NET
1. Abrir ligaçãoSqlConnection conn = new SqlConnection("SERVER=SQLSERVER; INTEGRATED SECURITY = TRUE; INITIAL CATALOG=ISEP");conn.Open();OU (http://msdn2.microsoft.com/en-us/library/8xx3tyca(VS.80).aspx)using (SqlConnection connection = new SqlConnection("Server=MSSQL1;uid=xxx;pwd=xxx;database=master")) { connection.Open(); command.ExecuteNonQuery("USE " + databaseName); }
2. Executar comandoSqlCommand cmd = new SqlCommand();cmd.Connection = conn;cmd.CommandText = "SELECT cod, descricao FROM detalhes WHERE zona=42 “;SqlDataReader reader = cmd.ExecuteReader();
3. Processar linhas no readerwhile(reader.Read()){
int cod = (int)reader[O];cmbDescricao. Items.Add(reader[1].ToString());
}
4. Fechar readerif(!reader.IsClosed)
reader.Close();
5. Fechar ligaçãoconn.Close();
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 8
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 9
C# - ADO.NET
1. Abrir a ligaçãoSqlConnection conn = new SqlConnection("SERVER=SQLSERVER; INTEGRATED SECURITY = TRUE; INITIAL
CATALOG=ISEP");conn.open();
2. Preencher o DataSetSystem.Data.DataSet ds = new System.Data.DataSet(); System.Data.Sql.sqlDataAdapter da =new System.Data.Sql.SqlDataAdapter();SqlCommand cmd = new SqlCommand();cmd.CommandText = "SELECT * FROM [DETALHES]";cmd.Connection = conn;da.SelectCommand = cmd;da.Fill(ds);
3. Fechar a ligaçãoconn.Close() ;
4. Processar o DataSetforeach(DataRow r in ds.Tables[O] .Rows)
r ["preco"] = r[preco] * 1.05;5. Abrir a ligação
conn.Open() ;6. Actualizar a fonte de dados
System.Data.Sql.SqlDataAdapter da = new System.Data.Sql.SqlDataAdapter("SELECT * FROM [DETALHES]", conn); System.Data.Sql.SqlCommandBuilder cb =new System.Data.Sql.SqlCommandBuilder(da);da.Update(ds) ;
7. Fechar a ligaçãoconn.Close() ;
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 10
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 - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 11
C# - ADO.NET
// Definir uma ligação a um fornecedor do tipo OLEDB para Access OleDbConnection conn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0iData Source= C:\DSN\Teste.mdbiPersist Security Info=False");
//Abrir a ligaçãoconn.Open();//Definir um novo comando do tipo OLEDBOleDbCommand cmd = new OleDbCommand();//Colocar o texto do comandocmd.CommandText = "SELECT NOME FROM PESSOA WHERE NUMERO = ?“;//Indicar ao comando qual é a ligação que vai usarcmd.Connection = conn;//Definir um parametro do tipo inteiro para conter o "Número" OleDbParameter parm = cmd.Parameters.Add(new OleDbParameter("@Numero", OleDbType.Integer));//Colocar o valor do parametro "Número". Quero saber o nome do cliente cujo código é 1...cmd.Parameters["@Numero"] .Value=l;//Executar o comando que só irá retornar um valor//Converter o resultado numa string//Colocar o valor de retorno na respectiva caixa de textotxtNome.Text = cmd.ExecuteScalar() .ToString();//Fechar a ligaçãoconn.Close();
Executar comandos que retornem um só registo
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 12
C# - ADO.NET
//Definir uma ligação a um fornecedor do tipo OLEDB para Access OleDbConnection conn = new
OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0iData Source= C:\DSN\Teste.mdbiPersist Security Info=False");//Abrir a ligaçãoconn.Open();//Definir um novo comando do tipo OLEDBOleDbCommand cmd = new OleDbCommand();//Colocar o texto do comandocmd.CommandText = "INSERT INTO TRABALHOS VALUES(?, ?)";//Indicar ao comando qual é a ligação que vai usarcmd.Connection = conn;//Definir os parametros para inserir os valoresOleDbParameter parmNumero = cmd.Parameters.Add(new OleDbParameter("@Numero", OleDbType.Integer));OleDbParameter parmNome = cmd.Parameters.Add(new OleDbParameter("@Nome", OleDbType.Char)) ;// Inserir os valoresfor(int i=O; i<cmbNomes.Items.Count; i++){
parmNumero.Value = i+l;parmNome.Value = cmbNomes.Items[i];//Executar o comando para inserir os valorescmd.ExecuteNonQuery();
}//Fechar a ligaçãoconn.Close();
Executar comandos que não retornem registos (inserir, actualizar ou remover registos)
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 13
C# - ADO.NET
//Definir uma ligação a um fornecedor do tipo OLEDB para Access OleDbConnection conn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source= C:\DSN\Teste.mdb;Persist Security Info=False");
//Abrir a ligaçãoconn.Open() ;//Definir um novo comando do tipo OLEDBOleDbCommand cmd = new OleDbCommand();//Colocar o texto do comandocmd.CommandText = "SELECT NOME FROM PESSOA";//Indicar ao comando qual é a ligação que vai usarcmd.Connection = conn;//Definir um DataReader para ler os dados//DataReader = forward only, read only. Muito rápido.//Executar o comando e associá-lo ao readerOleDbDataReader reader = cmd.ExecuteReader();//Percorrer o reader e colocar os valoreswhile(reader.Read())cmbNomes.Items.Add(reader[O] .ToString());//Se o reader não estiver fechado, fechar...if( !reader.IsClosed )
reader.Close();//Fechar a ligaçãoconn.Close() ;
Executar comandos que retornem registos para preenchimento de informação
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 14
C# - DataSet
Os resultados obtidos através da execução de comando através do ADO.NET podem ser processados directamente ou colocados num objecto ADO.NET DataSet.
O objecto Dataset contém um ou mais objectos Data Table. Assim, os dados que vão “alimentar” a aplicação estão armazenados neste objecto.
Construtores
Eventos
usado pelo .Net. Não é para ser utilizado directamenteDataset(SerializationInfom StreamingContext)
Cria um Dataset, com um determinado nomeDataset(string Nome)
Cria um DatasetDataset()
Ocorre quando o método Merge falha MergeFailed
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 15
C# - DataSet
Propriedades
Colecção de tabelas. Contém objectos DataTableTables
Colecção de relações. Contém objectos DataRelationRelations
Prefixo do namespace usado quando o Dataset grava ou carrega os dados para o XMLPrefix
Nome do namespace usado quando o Dataset grava ou carrega os dados para o XMLNamespace
Indica se o Dataset tem ou não errosHasErrors
Definições de linguagens, usadas para comparar stringsLocale
Colecção de propriedades dinâmicasExtendedProperties
Controla se o Dataset vai ou não forçar constraintsEnforceConstraints
Indica se o Dataset está ou não em modo DesignDesignMode
Nome do DatasetDatasetName
Controla se as comparações de strings são ou não sensíveis a Maiúsculas / MinusculasCaseSensitive
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 16
C# - DataSetMétodos
Escreve o conteúdo do esquema do DataSet em XML Schema, para um ficheiro, stream, TextReader ou XMLReader.
WriteXmlSchema
Escreve o conteúdo do DataSet em XML, para um ficheiro, stream, TextReader ou XMLReader.WriteXml
Faz um reset ao Dataset, de forma a que fique com estado original do DatasetReset
Lê informação XML schema a partir de um ficheiro, stream, TextReader ou XMLReader.ReadXmlSchema
Lê dados XML a partir de um ficheiro, stream, TextReader ou XMLReader.ReadXml
Carrega e sincroniza dados de outro Dataset, DataTable ou Array de DataRows para o Dataset que chama o método.
Merge
Indica se há alguma alteração pendente no Dataset.HasChanges
Devolve o schema do Dataset em XML (string)GetXmlSchema
Devolve os dados do Dataset em XML (string)GetXml
Cria um novo Dataset com o mesmo schema, mas apenas com as linhas que foram modificadas do Dataset original
GetChanges
Novo Dataset com o mesmo schema e com os mesmos dadosCopy
Cria um novo Dataset com o mesmo schema, mas sem dadosClone
Apaga todos os DataTable’s do DatasetClear
Usado internamente pelo Visual Studio .Net, antes e depois de adicionar informação sobre o Schema do Dataset
BeginInit e EndInit
Aceita / Rejeita todas as alterações pendentes Dentro do Dataset. Funciona com um Commit / Rollback local. Aceita todas as alterações pendentes Dentro do Dataset. Funciona com um Commit local.
AcceptChanges– RejectChanges
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 17
C# - DataSet
//Definir um DataSet chamado "AULAS"DataSet dsAulas = new DataSet("AULAS");//Definir as DataTableDataTable dtAlunos;DataTable dtInscricoes;//Dizer que as tabelas pertencem ao DataSetdtAlunos = dsAulas.Tables.Add("ALUNOS");dtInscricoes = dsAulas.Tables.Add("INSCRICOES");//Definir a estrutura das tabelasdtAlunos.Columns.Add("NUMERO", typeof(int));dtAlunos.Columns.Add("NOME", typeof(string));dtInscricoes.Columns.Add("NUMERO_ALUNO", typeof(int)); dtInscricoes.Columns.Add("NUMERO_DISCIPLINA", typeof(int));//Definir as chaves primárias das tabelas dtAlunos.Constraints.Add("PK_ALUNOS", dtAlunos.Columns["NUMERO"], true); dtInscricoes.Constraints.Add("PK_INSCRICOES", newDataColumn[] {dtInscricoes.Columns["NUMERO_ALUNO"], dtInscricoes.Columns["NUMERO_DISCIPLINA"]}, true);//Definir as relações entre as tabelas dsAulas.Relations.Add("R_ALUNO_DISCIPLINAS",dtAlunos.Columns["NUMERO"],dtInscricoes.Columns["NUMERO_ALUNO"]);//Mostrar o DataSet numa grelhadgAulas.DataSource = dsAulas;//Mostrar uma tabela especifica do DataSetdgAulas.DataMember = "ALUNOS";
Criar um DataSet programaticamente
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 18
C# - DataSet
Um objecto Dataset consiste num repositório de dados em memória, no lado do cliente, e apresenta-se como o principal representante do conjunto de objectos do modelo ADO.NET a suportar a arquitectura desconectada.
Um objecto Dataset nada sabe acerca da fonte de dados de onde provêm os seus dados, podendo estes provirem de diferentes bases de dados. Isto acontece porque, o objecto Data Adapterserve de ponte entre o DataSet e a base de dados, pois utiliza a informação de como ligar e aceder à base de dados (a partir dos objectos connection e command), ao mesmo tempo que proporciona métodos para preencher o DataSet de dados, assim como para efectivar a alteração dos dados, realizada ao nível do DataSet, na fonte de dados.
Um objecto Dataset consiste numa hierarquia de um ou mais objectos Data Table e Data Relation.
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 19
C# - DataSet
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 20
C# - DataSet
Um objecto Data Table consiste de um ou mais objectos Data Column, Data Rowe Constraint.
Um objecto Data Relation define o modo como as tabelas de um objecto Datasetestão relacionadas. O objecto Data Relation é essencialmente utilizado para gerir as restrições e, desse modo, simplificar a navegação entre tabelas relacionadas.
Os objectos Data Column definem os dados em cada coluna da tabela, incluindo o seu nome, tipo de dados, etc.
Os objectos Data Row contêm os dados para cada registo da tabela.
Os objectos Constraint são utilizados para manter a integridade dos dados. Uma restrição de chave primária assegura que os valores numa coluna, tal como a coluna de chave primária, são únicos. Uma restrição de chave forasteira determina como os registos de uma tabela são afectados quando os registos correspondentes duma tabela relacionada são alterados ou eliminados.
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 21
C# - DataTable
Construtores
usado pelo .Net. Não é para ser utilizado directamenteDataTable(SerializationInfo
StreamingContext)
Cria um novo DataTable com um determinado nomeDataTable(nome)
Cria um novo DataTableDataTable()
Antes de uma linha ser apagadaRowDeleting
Depois de uma linha ser apagadaRowDeleted
Antes do conteúdo de uma linha ser alteradoRowChanging
Depois do conteúdo de uma linha ser alteradoRowChanged
Antes do conteúdo de uma coluna ser alteradoColumnChanging
– Depois do conteúdo de uma coluna ser alteradoColumnChanged
Eventos
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 22
C# - DataTable
Propriedades
Nome da DataTableTableName
Colecção de linhas (DataRow) da tabelaRows
Array de DataColumns com a chave primáriaPrimaryKey
Colecção com DataRelations, que contêm dados “pai”ParentRelations
Prefixo do namespace usado quando o DataTable grava ou carrega os dados para o XMLPrefix
Nome do namespace usado quando o DataTable grava ou carrega os dados para o XMLNamespace
Quantidade (em linhas-rows) de memória que o DataTable reserva inicialmenteMinimumCapacity
Definições de linguagens, usadas para comparar stringsLocale
Indica se há algum erro na tabelaHasErrors
Colecção de propriedades dinâmicasExtendedProperties
Indica se o DataTable está em modo designDesignMode
DataView por defeitoDefaultView
Dataset onde o DataTable está (null se não estiver associado a nenhums dataset)DataSet
Colecção de constraintsConstraints
Colecção de colunas (DataColumn)Columns
Colecção com DataRelations, que contêm dados dependentesChildRelations
Controla se é ou não sensível a maiusculas/minu.CaseSensitive
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 23
C# - DataTable
Métodos
Devolve um array de DataRows, baseado num determinado critério de pesquisaSelect
Faz um reset ao DataTable, de forma a que fique com estado original do DataTableReset
Cria e devolve uma nova linha do DataTable (vazia)NewRow
Adiciona uma linha ao DataTable, passando os valores dessa linha através de um arrayLoadDataRow
Importa uma linha já existente para o DataTableImportRow
Devolve um array de DataRows, referentes às linhas que têm errosGetErrors
Cria um novo DataTable com o mesmo schema, mas apenas com as linhas que foram modificadas do DataTable original
GetChanges
Devolve o valor de uma expressão agregada (ex: sum, max,...), baseado no conteudo do DataTableCompute
Cria um novo DataTable, com o mesmo schema e mesmo dadosCopy
Cria um novo DataTable, com o mesmo schema, mas sem dadosClone
Apaga todas as linhas do DataTableClear
Desliga e volta a ligar as constraints. Util para carregar dadosBeginLoadData – EndLoadData
Usado internamente pelo Visual Studio .Net, antes e depois de adicionar informação sobre o Schema do DatasetBeginInit – EndInit
– Aceita/rejeita todas as alterações pendentes da tabela (como commit/rollback para dados locais)AcceptChanges – RejectChanges
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 24
C# - DataColumnPropriedades
Controla se a coluna necessita ou não de ter valores unicosUnique
DataTable a que pertence a colunaTable
Controla se a coluna é ou não só de leituraReadOnly
Indice da coluna na colecção de colunas do DataTableOrdinal
Prefixo do namespace usado grava ou carrega os dados para o XMLPrefix
Nome do namespace usado quando grava ou carrega os dados para o XMLNamespace
Tamanho máximo das colunas stringMaxLength
Colecção de propriedades dinâmicasExtendedProperties
linhasControla como o ADO.Net calcula o valor da coluna (para colunas baseadas em expressões)Expression
Controla o valor por defeito para esta coluna, quando são criadas novasDefaultValue
Controla o tipo de dados armazenado pela colunaDataType
Nome do objecto DataColumnColumnName
Controla como o ADO.Net armazena o conteudo da coluna em XMLColumnMapping
Titulo da coluna quando numa grelhaCaption
controla quanto o autoincrementa saltaAutoIncrementStep
1º valor do autoincrementAutoIncrementSeed
Controla se a coluna gere valores autoincrementAutoIncrement
– Controla se a coluna aceita ou não NULLsAllowDBNull
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 25
C# - DataRow
Propriedades
Tabela a que pertence o DataRowTable
Estado da linha. Valores possíveis: Added; Deleted; Detached (linha não pretence ainda a um DataTable); Modified; Unchanged
RowState
Informação sobre o erro associada à linhaRowError
Acesso aos valores da linha, usando um array de objectosItemArray
Propriedade indexada que permite o acesso (ler e alterar) os valores da linha. Indice- nº ordem da coluna; nome; referência ao DataColumn correspondente.
Item
Indica se a linha tem ou não errosHasErrors-
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 26
C# - DataRow
Métodos
Alterar a informação de erro da linha “pai”, com base numa DataRelatioSetParentRow
Alterar a informação de erro de uma determinada colunaSetColumnError
Indica se uma determinada coluna está ou não NulaIsNull-
Indica se a linha tem não uma determinada versão dos dadosHasVersion
Devolve um array de DataRows, para as linhas “pai” da actual, com base numa DataRelationGetParentRows
Devolve um DataRow, para a linha “pai” da actual, com base numa DataRelationGetParentRow
Array de DataColumns, com todas as colunas que têm erros nesta linhaGetColumnsInError
Obtem informação de erro sobre uma coluna específicaGetColumnError
Devolve um array de DataRows, para linhas dependentes da actual, com base numa DataRelation
GetChildRows
Apaga a linha. Na realidade, a linha fica apenas marcada para apagar (RowState = Deleted)Delete
Limpa os erros associados à linhaClearErrors
Inicia, Cancela ou Guarda (localmente) o processo de alteração dos dados da linhaBeginEdit – CancelEdit – EndEdit
Aceita ou Rejeita as alterações da linha.AcceptChanges – RejectChanges
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 27
C# - Exemplos
Exemplos:
DataRow row= Tabela.Rows.Find(“ValorAProcurar”);
DataRow row= Tabela.Rows.Find(3323);
...
object[] criterio = new object[] {“Valor1”, 4343};
DataRow row= Tabela.Rows.Find(criterio);
Find- Método da DataRowColection, que procura uma linha com base na sua chave primária
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 28
C# - Exemplos
DataRow[] Linhas = Tabela.Select(“(Pais=’PT’) and (cidade <> ‘Leiria’)”);
...
Exemplos de Expressões no Selectxpto LIKE ‘%a’ - xpto acaba em axpto LIKE ‘a%’ – xpto começa por axpto = ‘O’’Brian’ - xpto = O’Brian (1 plica = 2 plicas)#01/01/2003# - Datas[campo com espacos] = 23 - Campos podem ter espaços, desde que fiquem entre parentesis rectos
Ordenar linhas devolvidas pelo SelectDataRow[] Linhas = Tabela.Select(“Pais=’PT’, “Cidade DESC”);DataRow[] Linhas = Tabela.Select(“Pais=’PT’, “Cidade ASC”);
Linhas com determinado RowStatus devolvidas pelo Select DataViewRowState Estado;Estado = DataViewRowState.ModifiedOriginal | DataViewRowState.DeletedDataRow[] Linhas = Tabela.Select(“”, “”, Estado); //Devolve as linhas que foram modificadas ou apagadas.
Select- Método da DataTable, que devolve um array de linhas, baseado num determinado critério.
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 29
C# - DataGrid
O contolo DataGrid permite apresentar dados de uma tabela ou de uma colecção.
Os programadores podem selecionar quais as colunas que vão apresentar dados, personalizar as colunas, dotá-las de um cabeçalho e tratar os eventos que ocorrem quando o utilizador selecciona uma linha ou célula específica.
Fontes de dados que podem ser apresentadas numa DataGrid:
Objecto DataTable;
Objecto DataView;
Objecto ArrayList;
Qualquer componente que implemente os interfaces IListSources ou IList;
É permitido apresentar um objecto DataTable contido num DataSet.
//myDataSet may contain more than one DataTableDataTable myDataTable = myDataSet.Tables[“Customers”];dataGrid1.DataSource = myDataTable;
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 30
C# - DataGrid
Por defeito o objecto DataGrid apresenta todas as colunas e todas as linhas da fonte de dados (DataSource), sendo o título das colunas o nome das colunas.
A propriedade CurrentCell permite obter ou especificar o Focus de uma determinada célula.
//Set Focus to cell 3,5mydataGrid1.CurrentCell =new DataGridCell(3,5);
O objecto DataGrid pode ser formatado em termos de apresentação. Pode-se modificar as cores do background, das linhas, dos títulos, das linhas selecionadas, e etc.
De forma a criar um estilo para a DataGrid, é instanciar um objecto DataGridTableStyle, adicionar um objecto DataColumnGridStyle a cada coluna que se pretende apresentar e finalmente associar o DataGridTableStyle à propriedade TableStyles do objecto DataGrid
ESTCB - IPCBDepartamento de Engenharia Informática Projecto de Sistemas Industriais, Carlos Alves - 2006/07 31
C# - DataGrid
//Definir um DataSet chamado "AULAS“DataGridTableStyle ts1 = new DataGridTableStyle();ts1.MappingName = “Customers”;
/* Adicionar GridColumnStyle e associar um nome ao DataColumn na DataTable Especificar o título da Coluna e o tamanho */ DataGridColumnStyle boolCol = new DataGridTextBoxColumn();boolCol.MappingName = “Current”;boolCol.HeaderText = “IsCurrent Customer”;boolCol.Width = 150;ts1.GridColumnStyles.Add(boolCol);
// Uma nova colunaDataGridColumnStyle TextCol = new DataGridTextBoxColumn();TextCol.MappingName = “CustName”;TextCol.HeaderText = “Customer Name”;TextCol.Width = 250;ts1.GridColumnStyles.Add(boolCol);
//Associar o datagrigTableStyle ao GridTablestylesCollection.DataGrid1.TableStryles.Add(ts1);