C#NET

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
 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
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
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
 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
 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
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
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
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
}
}
}
ESTCB - IPCB
C# - Excepções - catch
namespace MyThrow {
using System;
public class Test {
public static void Main() {

t.Func1(); OUTPUT:
}
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…
throw new System.Exception();
Console.WriteLine("Exit try Block...");
}
catch
{
Console.WriteLine("Exception caught and handled");
}
}
}
}
ESTCB - IPCB
C# - Excepções – catch – exemplo 2
namespace MyThrow {
using System;
public class Test {
public static void Main() {

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

throw new System.Exception();
}
}
}
ESTCB - IPCB
C# - Excepções – catch dedicados
namespace MyDedicatedCatch
{
using System;
public class DedicatedCatch
{
{
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
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
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
C# - Excepções – finally
{
using System;
{
{
t.TestFunc();
Console.ReadLine();
}

{
if (num2==0)
throw new System.DivideByZeroException();
if (num1==0)
return num1/num2;
}
ESTCB - IPCB
C# - Excepções – finally 2

{
try{
Console.WriteLine("Open the file here.");
double a = 5;
double b = 0;
}
catch (System.DivideByZeroException){
Console.WriteLine("DivideByZeroException caught!");
}
catch {
}
finally
{
Console.WriteLine("Close the file here.");
}
}
}
}
ESTCB - IPCB
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
C# - Objecto Excepção
{
using System;
{
{
t.TestFunc();
Console.ReadLine();
}
{
if (num2==0){
DivideByZeroException e = new DivideByZeroException();
e.HelpLink = "http://www.libertyassociates.com";
throw e;
}
if (num1==0)
return num1/num2;
}
ESTCB - IPCB
C# - Objecto Excepção 2
{
try {
Console.WriteLine("Open the file here.");
double a = 5;
double b = 0;
}
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);
}
catch {
}
finally
{
Console.WriteLine("Close the file here.");
}
}
}
}
ESTCB - IPCB
C# - Objecto Excepção 3
ESTCB - IPCB
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
 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
 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
 É 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
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
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
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
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
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
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
 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
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
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
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
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;
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
 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
 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
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
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
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.
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
C#.NET
Parte II
ESTCB - IPCB
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

C# - Estruturas
 Uma estrutura consiste num tipo de dados definido pelo utilizador.
 As estruturas são semelhantes às classes, pois possuem construtor,

propriedades, métodos, operadores, etc..
 Diferem das classes na medida em que não possuem destrutores nem permitem
herança.
 Geralmente opta-se pelo uso de estruturas quando se pretende representar tipos

de dados pequenos, simples e similares no seu comportamento e características.
 Definição técnica de uma estrutura:
[attributes] [acess-modifiers] struct identifier [:interface-list]
{struct members};

C# - Estruturas
using System;
namespace MyStruct
{
public struct Location
{
private int xVal;
private int yVal;
public Location (int xCoordinate, int yCoordinate)

{
xVal = xCoordinate;
yVal = yCoordinate;
}
public int x
{
get
{
return xVal;
}
set
{
xVal = value;
}
}

C# - Estruturas
public int y
{
get
{
return yVal;
}
set
{
yVal = value;
}
}
public override string ToString()

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

C# - Estruturas
/// <summary>
/// Summary description for Class1.
/// </summary>
public class Tester
{
public void myFunc (Location loc)
{
loc.x = 50;
loc.y = 100;
Console.WriteLine("In MyFunc loc: {0}", loc);
}
static void Main()
{
Location loc1 = new Location(200,300);
Console.WriteLine("Loc1 location: {0}", loc1);
Tester t = new Tester();
t.myFunc(loc1);
Console.WriteLine("Loc1 location: {0}", loc1);
}
}
}

C# - Estruturas
 Sem destrutor ou construtor por defeito:
 Estruturas não possuem destrutores, nem possuem construtor por defeito

sem parametros.
 Se não for fornecido construtor, será fornecido um por defeito que colocará
todos os membros a zero. Se existir um construtor, é obrigatório inicializar os
membros.
 Sem inicialização:
 Não é permitido inicializar os membros dentro da estrutura. Sendo assim é

ilegal proceder à seguinte codificação:
privare int xVal = 50;
privare int xVal = 50;
 Isto tem que ser executado dentro da classe.

C# - Operador Overloading
 O operador overloading permite que classes definidas pelo utilizador possuam as

mesmas funcionalidades que os tipos de dados pré-definidos.
 Como exemplo suponha que possui uma classe para representar fracções,
Garantir que esta classe possui todas as funcionalidades que tipos de dados pré-
definidos, significa que a classe definida por si tem capacidade de executar as
mesmas operações que as classes de dados pré-definidos. (Exemplo: adicionar
duas fracções, multiplicar duas fracções, e converter fracções em dados do tipo
int).
Fraction theSum = firstFraction + secondFraction;
 Como o operador + já existe, será necessário efectuar um overloading do

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

Operador Comparação ==
 É bastante comum efectuar o overloading do operador ==, no entanto a

linguagem C# insiste que será necessário efectuar o mesmo para o operador !=.
O mesmo se passa em relação aos operadores < e >, será necessário

implementar o overloading dos operadores <= e =>.
 Sendo assim é preferível que se efectue antes um override ao método Virtual

Equals(). Isto permite que a classe seja polimórfica e fornece compatibilidade
com outras linguagens .NET que não suportam o overload de operadores (mas
suportam o método overloading).
 A classe objecto implementa o método Equals() da seguinte forma:
public virtual bool Equals (object o)

Operador Comparação ==
 Ao efectuar o override do método, garante-se que a classe
Fraction actue de forma polimórfica com outros objectos.
 Dentro do método é necessário garantir que o objecto a
comparar é um objecto do tipo Fraction.
public override bool Equals(object o)

{
if (! (o is Fraction))
{
return false;
}
return this == (Fraction) o;
}
 O operador is é utilizado para garantir que o objecto é compatível com o

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

Operadores de Conversão
 A linguagem C# permite conversão implicita e explícita.
 Por exemplo converter um int num long consiste numa conversão implítica, pois o
tamanho de um int cabe num long.
 A operação inversa traduz-se por uma conversão explícita.
int myInt = 5;
long myLong;
myLong = myInt // implicita
myInt = (int) myLong // explícita

namespace MyOverloading
{
using System;
public class Fraction

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

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

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

public static implicit operator Fraction(int theInt)

{
Console.WriteLine("In implicit conversion to Fraction");
return new Fraction (theInt);
}
public static explicit operator int(Fraction theFraction)

{
Console.WriteLine("In implicit conversion to int");
return (theFraction.numerator / theFraction.denominator);
}
public static bool operator == (Fraction lhs, Fraction rhs)

{
Console.WriteLine("In operator ==");
if ((lhs.denominator == rhs.denominator)&& (lhs.numerator == rhs.numerator))
{
return true;
}
// colocar código quando as frações são diferentes
return false;
}
public static bool operator != (Fraction lhs, Fraction rhs)

{
return !(lhs==rhs);
}

public override bool Equals(object o)

{
Console.WriteLine("In method Equals");
if (! (o is Fraction))
{
return false;
}
return this == (Fraction) o;
}
public static Fraction operator + (Fraction lhs, Fraction rhs)
{
Console.WriteLine("In operator +");
if (lhs.denominator == rhs.denominator)
{
return new Fraction (lhs.numerator+rhs.numerator, lhs.denominator);
}
// simlistic solution for unlike fractions
// 1/2 + 3/4 == (1*4) + (3*2) / (2*4) = 10/8
int firstProduct = lhs.numerator * rhs.denominator;
int secondProduct = lhs.denominator * rhs.numerator;
return new Fraction (firstProduct+secondProduct, lhs.denominator*rhs.denominator);
}
{
string s = numerator.ToString() + "/"+denominator.ToString();
return s;
}
}

public class Tester

{
static void Main()

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

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

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

C# - Interfaces
 Uma interface consiste basicamente num contracto com o cliente

de sobre o comportamento de uma determinada classe ou
estrutura.
 Quando uma classe implementa uma interface, isto significa, que
essa classe garante que suporta todos os métodos, propriedades
e eventos da referida interface.
 Sintáticamente, uma interface é semelhante a uma clase que
possui somente métodos abstractos.
 A implementação de uma interface implica relações.
 Um carro é um veículo, no entanto pode implementar a

capacidade PodeSerCompradoComRecursoCredito.
[attributes] [access-modifier] interface interface-name [:base-

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

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

C# - Interfaces
Implementando mais do que uma interface
 É permitido que uma classe implemente mais do que uma interface, bastando
para isso indicar o nome das interfaces, separadas por uma vígula.
public class Document : IStorable, ICompressible
Extensão de interfaces
 É possível a uma interface herdar as caraterísticas de outra interface.
interface ILoggedCompressible : ICompressible
 As classes são livres de implementar a interface que lhes convém mais, no

entanto classes que implementem a interface ILoggedCompressible têm que
implementar os métodos de ambas as interfaces.

C# - Interfaces
Junção de Interfaces.
 É possível desenvolver novas interfaces a partir da junção de
interfaces já existentes e opcionalmente adicionar novos
métodos ou propriedades.
interface IStorableCompressible : IStorable, ILoggedCompressible
void LogOriginalSize();
 Esta interface combina os métodos das outras duas interfaces e implementa um

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

C# - Interfaces
namespace MyInterfaceCombining
{
using System;
interface IStorable {
void Read();
void Write(object obj);
int Status { get; set; }
}
// here's the new 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();
}

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

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

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

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

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″);
}
C# - Vectores
 Um vector (Array) consiste numa coleção indexada de dados do mesmo

tipo.
 Relativamente à liguagem C#, os vectores diferem das outras

linguagens na medida em que todos os dados constituintes do vector
são objectos.
 Declaração de um vector: type [] array-name;
 Os parênteses rectos indicam ao compilador que se trata de um vector.
 A instanciação de um vector é efectuada recorrendo à palavra new:

int[] myIntArray;
myIntArray = new int[5];
 A declaração anterior permitiu declarar um vector de 5 elementos

inteiros, e alocar memória para os mesmos.

C# - Vectores
Valores por defeito
 Ao criar um vector de elementos do tipo valor, cada elemento do vector será

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

null, ou seja, se tentar aceder a um elemento do vector sem o ter inicializado
primeiro, provocará uma excepção.
 O seguinte exemplo:
Button[] myButtonArray = new Button [3];
Não cria um array com três objectos Button, mas sim um vector de 3 elementos
do tipo Button. Para conter objectos deste género, será necessário primeiro
inicializar cada elemento com um objecto deste tipo.

C# - Vectores
Aceder aos elementos
 A indexação de um vector é inicializada a zero, e cada elemento terá que ser

acedido pela sua posição dentro de [].
 Como referido anteriormente, os vectores são objectos, logo possuem

propriedades, sendo uma delas a length (tamanho). Como os vectores são
indexados a zero, é necessário ter em consideração que a última posição do
vector é length-1

C# - Vectores
namespace MyArrayFor
{
using System;
public class Employee

{
private int empID;
public Employee(int empID)

{
this.empID = empID;
}

{
return empID.ToString();
}
}

C# - Vectores
public class Tester
{
static void Main()

{
int[] intArray;
Employee[] empArray;
intArray = new int[5];
empArray = new Employee[3];
//populate the 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());
}

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

C# - Vectores - foreach
public class Tester
{
static void Main()

{
int[] intArray;
Employee[] empArray;
intArray = new int[5];
empArray = new Employee[3];
//populate the array

{
empArray[i]= new Employee(i+5);
}
foreach (int i in intArray)

{
Console.WriteLine(intArray[i].ToString());
}
foreach (Employee e in empArray)

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

C# - Vectores
Parâmetros - params
 Permite a passagem de diversos parâmetros para um método, sem ser

necessário especificar no método quantos parâmetros são.
namespace MyArrayParams
{
using System;
public class Tester
{
static void Main ()
{
Tester t = new Tester();
t.DisplayVals(5,6,7,8);
int [] explicitArray = new int[5] {1,2,3,4,5};
t.DisplayVals(explicitArray);
}
public void DisplayVals (params int[] intVals)
{
foreach (int i in intVals)
{
Console.WriteLine("Displays {0}", i);
}
}
}
}

C# - Vectores Multidimensionais
Regulares
 Um vector multidimensional regular é um vector que possui o mesmo
número de colunas para todas as linhas.
 Num array multimensional de duas dimensões, a 1ª consiste no número

de linhas enquanto a 2ª dimensão representa o número de colunas.
 Declaração de um vector de duas dimensões:
int [,] myRectangleArray = new int [2,3];
 A existência de uma vírgula indica que o vector é de duas dimensões

(duas vírgulas indica 3 dimensões e por aí adiante).
 Neste género de vectores também é possível utilizar a inicialização

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

C# - Vectores Multidimensionais
Jagged
 Um vector vector jagged consiste num vector de vectores, onde cada linha não
tem obrigatoriamente de ter o mesmo número de colunas das anteriores.
 Ao criar um vector jagged, define-se unicamente o número de linhas do mesmo.

Cada linha irá conter então um outro vector, o qual terá o tamanho desejado.
 Definição de um vector jagged:
int [][] myMyJagged = new int [rows][];

C# - Vectores - jagged
namespace MyJaggedArray
{
using System;
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

// a row with 3 elements

// the last row has 5 elements


C# - Vectores - jagged
// Fill some (but not all) elements of the rows
jaggedArray[0][3] = 15;
for (int i = 0;i < 5; i++){

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

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

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

C# - Vectores - ArrayList
 O problema com o tipo vector é o seu tamanho fixo. Se não for possível ter um
conhecimento antecipado de quantos objectos será necessário armazenar, corre-
se o risco de declarar ou um vector muito grande, ou um vector que não
preenche as necessidades.
 Sendo assim a linguagem C# possui uma classe de dados denominada ArrayList,

cujo tamanho pode ser dinâmicamente incrementado à medida das necessidades.
 Esta classe possui métodos e propriedades que ajudam bastante na sua

utilização.

C# - Vectores - ArrayList
namespace MyArrayList
{
using System;
using System.Collections;
// a simple class to store in the array
public class Employee
{
public Employee(int empID)
{
this.empID = empID;
}
{
return empID.ToString();
}
public int EmpID
{
get
{
return empID;
}
set
{
empID = value;
}
}
private int empID;
}

C# - Vectores - Dicionários
 Um dicionário consiste numa colecção de dados que associa uma chave a um

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

chave (string, integer, object, etc) a qualquer tipo de valores (string, integer,
object, etc).
 A característica mais importante de um dicionário é que seja de fácil utilização,

isto é, que seja fácil de inserir novos valores e rápido a devolver os mesmos.
Hashtables
 É um tipo de dicionário optimizado para aceder a valores rápidamente.
 Numa hash table cada valor é armazenado num bucket, o qual é numerado de
forma semelhante ao offset de um vector.
 A chave de uma hash table não necessita de ser inteira.

C# - Vectores - hashtables
namespace MyHash
{
using System;
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"]);
}
}
}

C# - Vectores - hashtables
namespace MyHashProperties
{
using System;
public class Tester
{
static void Main( )
{
hashTable.Add("000440312", "George Washington");
hashTable.Add("000123933", "Abraham Lincoln");
// 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);
}
}
}
}

C# - Vectores - IDictionaryEnumerator
namespace MyDictionaryEnumerator
{
using System;
public class Tester
{
static void Main( )
{
hashTable.Add("000440312", "George Washington");
hashTable.Add("000123933", "Abraham Lincoln");
// Display the properties and values of the Hashtable.

Console.WriteLine( "hashTable" );
Console.WriteLine( " Count: {0}", hashTable.Count );
Console.WriteLine( " Keys and Values:" );
PrintKeysAndValues( hashTable );
}
public static void PrintKeysAndValues( Hashtable table )
{
IDictionaryEnumerator enumerator = table.GetEnumerator( );
while ( enumerator.MoveNext( ) )
Console.WriteLine( "\t{0}:\t{1}",enumerator.Key, enumerator.Value );
Console.WriteLine( );
}
}
}

C# - Vectores
 Para além dos vectores anteriormente referidos, existem ainda os

seguintes:

C#.NET
Parte III
ESTCB - IPCB
Sumário – C#.NET
 ADO.NET
 DataSet
 DataTable
 DataColumn
 DataRow
 DataGrid
ESTCB - IPCB Projecto de Sistemas Industriais, Carlos Alves - 2006/07 2

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

C# - ADO.NET
 A nível do armazenamento de Dados, o ADO.NET suporta vários tipos:
 Não estruturados;
 Estruturados, não-hierárquicos
 Ficheiros CSV (Com ma Separated Value), Folhas Microsoft Excel, Ficheiros, o Microsoft
Exchange, o..
 Hierárquicos
 Documentos XML e outros
 Bases de Dados Relacionais
 SOL Server, Oracle, Access, ODBC, etc

C# - ADO.NET
 Um fornecedor de dados para ADO.NET é um conjunto de classes que
pode ser usado para efectuar ligações a bases de dados, manipular e
actualizar os dados:
 SQL Server .NET Data Provider
 OLE DB .NET Data Provider
 ODBC .NET Data Provider
 Outros (DB2/400, MySQL, ...)
 XxxConnection -exemplo, SqlConnection

 o XxxTransaction -exemplo, SqlTransaction
 o XxxException -exemplo, SqlException
 o XxxError -exemplo, SqlError
 XxxCommand -exemplo, SqlCommand

 o XxxParameter -exemplo, SqlParameter
 XxxDataReader -exemplo, SqlDataReader

 XxxDataAdapter -exemplo, SqlDataAdapter
 XxxPermission -exemplo, SqlClientPermission
C# - ADO.NET
Cenários Conectados
 Um cenário conectado é aquele no qual os utilizadores estão permanentemente
ligados à bases de dados
 Vantagens:
 É mais fácil exercer segurança ao nível do ambiente;
 A concorrência é mais fácil de controlar;
 Os dados estão mais actualizados que nos outros cenários;
 Desvantagens
 É necessário haver uma ligação constante ao servidor;
 Escalabilidade;

C# - ADO.NET
1. Abrir ligaçã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;

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]";
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() ;

C# - ADO.NET
Namespaces necessários
 System.Data – para as classes base do ADO.net (ex, DataSet).

 System.Data.SqlClient – para as classes correspondentes ao provider para SQL
Server;
 System.Data.OleDb – para as classes correspondentes ao provider para OLE DB;
 System.Data.SqlTypes – para as classes correspondentes aos tipos de dados
nativos do SQL Server.
 System.Data.Common – para as estruturas de dados, classes e interfaces
comuns a todos os providers (ex, DataSet)
 System.Xml – para as classes de manipulação de XML via DataSet;

C# - ADO.NET
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
//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();

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();
cmd.CommandText = "INSERT INTO TRABALHOS VALUES(?, ?)";
//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();
}
conn.Close();

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() ;
cmd.CommandText = "SELECT NOME FROM PESSOA";
//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();
conn.Close() ;

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

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.

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

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
C# - DataSet

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

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

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

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

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

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

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

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.

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;

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

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


C#NET

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

C#NET

Загружено:

Авторское право:

Доступные форматы

Projecto de Sistemas Industriais

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

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

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

 Documentação integrada em XML;

 Suporte para propriedades, métodos e eventos

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

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

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

 Não tem templates

 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

 Segurança de tipos (type-safety)

 Semelhanças com C++ e Java

 Nenhum sacrifício necessário

 Cada vez mais importante

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

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

 Pequena curva de aprendizagem

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

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

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

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

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

 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

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

 Enumerações enum State {On, OFF}

 Estruturas struct Point {int x,y;}

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

 Classes class Foo:Bar,IFoo {…}

 Interfaces interface IFoo:IBar {…}

 Delegados delegate double MathFunc (double x);

CTS Type Name Tamanho .NET tipo Descrição

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

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

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

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

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

const int FreezingPoint = 32; constante simbólica

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

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

enum ServingSizes :uint

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

#region Funções de Teste

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

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

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

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