TREINAMENTO MICROSOFT

C# .NET

ÍNDICE

Microsoft .NET ............................................................................................................................... 4

ORIENTAÇÃO À OBJETOS............................................................................................................... 5

Namespace .................................................................................................................................... 5

Classes ........................................................................................................................................... 5

Objeto/ Instancia ........................................................................................................................... 5

Atributo/ Campo ........................................................................................................................... 5

Encapsulamento ............................................................................................................................ 5

Propriedade ................................................................................................................................... 5

Interface ........................................................................................................................................ 6

Método .......................................................................................................................................... 6

Herança ......................................................................................................................................... 6

Sobrecarga..................................................................................................................................... 7

Polimorfismo ................................................................................................................................. 8

Princípios do C# ............................................................................................................................. 8

Tipos primitivos ............................................................................................................................. 9

OPERADORES ................................................................................................................................. 9

Operador x++ ................................................................................................................................ 9

Operador x-- .................................................................................................................................. 9

Operador new ............................................................................................................................... 9

Operador typeof ............................................................................................................................ 9

Operador + .................................................................................................................................. 10

Operador - ................................................................................................................................... 10

Operador ! ................................................................................................................................... 10

Operador (T)x - CAST ................................................................................................................... 10

Operador true/ false ................................................................................................................... 10

Operador * .................................................................................................................................. 10

Operador / ................................................................................................................................... 11

Operador % ................................................................................................................................. 11

Operador < <= > >= ...................................................................................................................... 11

Operador == ................................................................................................................................ 11

Operador != ................................................................................................................................. 11

Operador && ............................................................................................................................... 11

Operador = .................................................................................................................................. 12

Operador += ................................................................................................................................ 12

Operador -= ................................................................................................................................. 12

Comando If .................................................................................................................................. 12

Comando for ............................................................................................................................... 13

Comando while ........................................................................................................................... 13

Comando foreach ........................................................................................................................ 14

Arrays .......................................................................................................................................... 14

Generics ....................................................................................................................................... 15

Tratamento de erros ................................................................................................................... 15

Acesso a banco de dados ............................................................................................................ 17

OLEDB .......................................................................................................................................... 17

Leitura e gravação de arquivos textos ........................................................................................ 19

Microsoft .NET Microsoft .NET (comumente conhecido por .NET Framework - em inglês: dotNet) é uma iniciativa da empresa Microsoft, que visa uma plataforma única para desenvolvimento e execução de sistemas e aplicações. Todo e qualquer código gerado para .NET, pode ser executado em qualquer dispositivo que possua um framework de tal plataforma.

Com idéia semelhante à plataforma Java, o programador deixa de escrever código para um sistema ou dispositivo específico, e passa a escrever para a plataforma .NET.

A plataforma .NET é executada sobre uma Common Language Runtime - CLR (Ambiente de Execução Independente de Linguagem) interagindo com um Conjunto de Bibliotecas Unificadas (framework). Esta CLR é capaz de executar, atualmente, mais de 20 diferentes linguagens de programação, interagindo entre si como se fossem uma única linguagem

A plataforma .NET baseia-se em um dos principios utilizados na tecnologia Java (Just In Time Compiler - JIT), os programas desenvolvidos para ela são duplo-compilados (compilados duas vezes), uma na distribuição (gerando um código que é conhecido como "bytecodes") e outra na execução.

Um programa é escrito em qualquer das mais de vinte linguagens de programação disponíveis para a plataforma, o código fonte gerado pelo programador é então compilado pela linguagem escolhida gerando um código intermediário em uma linguagem chamada MSIL (Microsoft Intermediate Language).

Este novo código fonte gera um arquivo na linguagem de baixo nível Assembly, de acordo com o tipo de projeto:

• EXE - Arquivos Executáveis, Programas • DLL - Biblioteca de Funções • ASPX - Página Web • ASMX - Web Service

No momento da execução do programa ele é novamente compilado, desta vez pelo compilador JIT, de acordo com a utilização do programa, por exemplo: Temos um Web Site desenvolvido em ASP.NET, ao entrar pela primeira vez em uma página o JIT irá compila-la, nas outras vezes que algum outro usuário acessar esta página, ele usará esta compilação.

Também é possível, através de ferramentas específicas, "pré-compilar" o código para que não se tenha o custo da compilação JIT durante a execução.

O fato desta arquitetura utilizar a MSIL gera uma possibilidade pouco desejada entre os criadores de software que é a de fazer a "engenharia reversa", ou seja, a partir de um código compilado, recuperar o código original. Isto não é uma idéia agradável para as empresas que sobrevivem da venda de softwares produzidos nesta plataforma.

Por causa disso, existem ferramentas que "ofuscam" o código MSIL, trocando nomes de variáveis, métodos, interfaces e etc para dificultar o trabalho de quem tentar uma engenharia reversa no mesmo.

ORIENTAÇÃO À OBJETOS

Namespace São grupos de classes, como se fossem diretórios de uma biblioteca. Elas são utilizadas para agrupar classes de uma mesma categoria. Duas classes podem ter nomes iguais se pertencerem à namespaces diferentes.

Classes Classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis destes objetos através de atributos. Em outros termos, uma classe descreve os serviços providos por seus objetos e quais informações eles podem armazenar.

Objeto/ Instancia Um objeto ou instancia é a materialização da classe. É a representação em memória de uma entidade ou estado. Exemplos de objetos da classe Humanos: João, José, Maria

Atributo/ Campo Representam característica ou estado de uma classe. Ex: nome, código, percentual

Encapsulamento Encapsular significa “esconder” as funcionalidades da classe. Apenas a classe tem conhecimento das regras, estados ou comportamentos. Essas funcionalidades não são visíveis fora da classe para manter a integridade da classe.

Propriedade Propriedade tem o comportamento de um campo, parece um campo mas é um

conjunto de dois métodos.

1) Leitura ou método get – Utilizado para obter o valor de um campo

2) Gravação ou método set – Utilizado para atribuir um valor para um campo

A propriedade é utilizada para “policiar” o conteúdo de um campo. Ou seja, impede

que valores indesejados sejam atribuídos aos campos. Mantendo a regra de negócio,

ou as regras de comportamento íntegras.

Interface É uma classe que não possui implementação. Por definição ela é abstrata, não contém código, apenas a assinatura ( cabeçalho ou header) da classe. A assinatura de uma classe contém apenas os nomes das propriedades, nome dos métodos, parâmetros, mas não possuem o corpo.

Método Método define as ações ou funções dos objetos. Pode-se associar com a definição de função ou procedimento. Bidu é uma instância da classe Cachorro, portanto tem habilidade para latir e morder. Um método em uma classe é apenas uma definição. A ação só ocorre quando o método é invocado através do objeto, no caso Bidu. Dentro do programa, a utilização de um método deve afetar apenas um objeto em particular; Todos os cachorros podem latir, mas você quer que apenas Bidu dê o latido. Normalmente, uma classe possui diversos métodos, que no caso da classe Cachorro poderiam ser sente, coma e morda

Herança é o mecanismo pelo qual uma classe (sub-classe) pode estender outra classe (super-classe), aproveitando seus comportamentos (métodos) e variáveis possíveis (atributos). Um exemplo de herança: Mamífero é super-classe de Humano. Ou seja, um Humano é um mamífero. Há herança múltipla quando uma sub-classe possui mais de uma super-classe. Essa relação é normalmente chamada de relação "é um" Exemplo: public class Poligono

{

protected double _area;

public double Area

{

get { return _area; }

}

protected double _perimetro;

public double Perimetro

{

get { return _perimetro; }

}

public virtual void CalcularArea()

{

}

public virtual void CalcularPerimetro()

{

}

}

public class Triangulo: Poligono

{

private double _lado1;

public double Lado1

{

get { return _lado1; }

set { _lado1 = value; }

}

private double _lado2;

public double Lado2

{

get { return _lado2; }

set { _lado2 = value; }

}

private double _lado3;

public double Lado3

{

get { return _lado3; }

set { _lado3 = value; }

}

public override void CalcularArea()

{

double s = (_lado1 + _lado2 + _lado3) / 2;

_area = Math.Sqrt(

s * (s - _lado1) +

s * (s - _lado2) +

s * (s - _lado3));

}

public override void CalcularPerimetro()

{

_perimetro = _lado1 + _lado2 + _lado3;

}

}

Notas:

Os campos _perimetro e _area foram definidos na classe Poligono e são consumidas na classe filha Triangulo. Isso só é possível pois ambos foram definidos como protected; Os métodos CalcularArea e CalcularPerimetro foram definidos na classe Poligono e são implementadas na classe filha Triangulo. Isso só é possível pois na classse pai Poligono os métodos foram definidos como “virtual” e na classe filha Triangulo foram definidas como “override”. Ou seja, virtual para os métodos do pai, e “override” para os métodos do filho

Sobrecarga Sobrecarga é definido por duas funções/métodos com o mesmo nome, mas assinaturas diferentes

Exemplo: public class Calculos

{

void Soma(int valor1, int valor2)

{

}

void Soma(float valor1, float valor2)

{

}

}

Neste exemplo os dois métodos possuem o mesmo nome, e este cenário só é possível pois os parâmetros são diferentes. O nome dos parâmetros não influencia na

sobrecarga, para haver sobrecarga os tipos dos parâmetros têm que ser diferentes entre os métodos.

Polimorfismo É a capacidade de um método, com os mesmos parâmetros, ter comportamentos diferentes em instâncias diferentes. RESUMO namespace Roca

{

/* classe */

class Humano

{

/* atributo ou campo */

private string nome;

/* assinatura ou cabeçalho da propriedade */

public string Nome

{

get { return this.nome; }

set { this.nome = value; }

}

/* assinatura ou cabeçalho do método */

public void Caminhar(int tempo)

{

/* corpo do método, implementação */

for (int i = 0; i < tempo; i++)

{

System.Console.WriteLine(“Passo “ +

i.ToString());

}

}

}

}

/* do lado esquerdo do igual, declaração da variável mulher do tipo Humano */

/* do lado direito do igual, instanciando o tipo Humano. Alocação de memória.

*/

Humano mulher = new Humano();

Mulher.Nome = “Maria”;

Princípios do C# Toda instrução C# termina com ponto-e-vírgula “;”. System.Console.WriteLine(“Teste de C#”); Uma instrução pode conter várias linhas, basta apenas continuar na linha de baixo, sem a necessidade de nenhum caracter para indicar a continuidade da instrução. O “;” indica o fim da instrução:

System.Console.WriteLine(

“Teste de C#”);

Tipos primitivos Os tipos primitivos é a menor unidade de armazenamento de dados. Através deles é possível

construir todos os objetos do C#. São eles:

object Todos os objetos do .NET são filhos de object. Este tipo pode armazenar

qualquer valor

bool Booleano (lógico), recebe true ou false

byte Número inteiro sem sinal de 8 bits, armazena valores de 0 a 255

short Número inteiro de 16 bits com sinal

ushort Número inteiro de 16 bits sem sinal

int Número inteiro de 32 bits com sinal

uint Número inteiro de 32 bits sem sinal

long Número inteiro de 64 bits com sinal

ulong Número inteiro de 64 bits sem sinal

float Número de ponto flutuante de 32 bits

double Número de ponto flutuante de 64 bits

char Representa um caracter UNICODE (2 bytes)

string Armazena uma cadeia de caracteres

DateTime Armazena valores do tipo data e hora

OPERADORES

Operador x++ Soma o valor um de uma variável x. É o mesmo que x = x + 1;

Operador x-- Subtrai o valor um de uma variável x. É o mesmo que x = x - 1;

Operador new Utilizado para instanciar uma classe.

Exemplo:

/* instancia um objeto do tipo TextBox na variável txt */

TextBox txt = new TextBox();

Operador typeof O operadora typeof permite passar tipos ou classes como parâmetro. Uma classe ou um tipo não pode ser passado por parâmetro pois não é uma instância, é apenas uma definição. O typeof permite criar uma instância contendo as características do tipo ou classe.

Exemplo: System.Console.WriteLine(typeof(int).Name); // Exibe o nome da classe

Operador + Operador para soma de dois valores.

Exemplo: x = 1 + 2;

x = x + y;

x = y + 5;

Operador - Operadora para a subtração de dois valores

Exemplo: x = 1 + 2;

x = x + y;

x = y + 5;

Operador ! Operador NOT, inverte uma expressão lógica, onde um resultado é verdadeiro transforma-se em falso, e onde um resultado é falso transforma-se em verdadeiro.

Exemplo: /* Testa se não chegou no final do arquivo */

if (!reader.EndOfStream)

System.Console.WriteLine(“Não terminou de ler o arquivo”);

Operador (T)x - CAST CAST, força o compilador a interpretar o tipo de uma variável. Variáveis do tipo object o compilador não consegue resolver em determinadas expressões. Não é uma conversão de tipo de dados, pois a conversão exige uso do processador para transformar um tipo em outro, enquanto o CAST apenas instrui o compilador a interpretar o tipo de dados corretamente. T é um tipo ou classe e x é uma variável.

object a = 10;

int i = a + 40; // Erro na compilação

int i = (int)a + 40; // Compilador não acusa erro

string b = (string)a; // Compilador não acusa erro, mas causa erro em

runtime

Operador true/ false Para operações lógicas, verificação de condições.

Exemplo: if (x == 1) System.Console.WriteLine(“Retornou true”)

Operador * Operador para multiplicação de dois valores.

Exemplo: x = 1 * 2;

x = x * y;

x = y * 5;

Operador / Operador para divisão de dois valores.

Exemplo: x = 1 / 2;

x = x / y;

x = y / 5;

Operador % Operador MÓDULO, retorna a diferença de uma divisão

Exemplo: x = 1 % 2; /* retorna 1 */

x = 2 % 2; /* retorna 0 */

Operador < <= > >= Menor que, menor ou igual que, maior que, maior ou igual que. Numa expressão (valor1 > valor2) testa se o valor1 é maior que valor2.

Operador == Operador relacional IGUAL, uma expressão (x == y) será verdadeira quando os valores x e y forem idênticos.

Exemplo 1: int x = 1;

if (x == 1) System.Console.WriteLine(“verdadeiro”);

Exemplo 2: /* testa se x é igual a 1 e o resultado (verdadeiro ou falso) */

/* é colocado na variável verdadeiro */

int x = 1;

bool verdadeiro = (x == 1);

Operador != Operadora relacional DIFERENTE (ou NOT EQUAL), uma expressão (x != y) será verdadeira se x for diferente de y.

Operador && Operador relacional OR, uma expressão ((condição1) || (condição2)) será verdadeira se qualquer uma das condições forem verdadeiras.

Exemplo 1: bool found = true;

bool codigo = 10;

if (found || (código == 10))

System.Console.WriteLine(“verdadeiro”);

Exemplo 2: /* neste exemplo os operadores lógicos == (igual) || (or) */

/* serão testados e o resultado verdadeiro ou falso será */

/* armazenado na variável transportadora */

bool transportadora = ((código == 10) || (tipo == “T”));

Operador relacional AND, uma expressão ((condição1) && (condição2)) será verdadeira se as duas condições forem verdadeiras.

Exemplo 3: bool found = true;

bool código = 10;

if (found && (código == 10))

System.Console.WriteLine(“verdadeiro”);

Exemplo 4: /* neste exemplo os operadores lógicos == (igual) && (and) */

/* serão testados e o resultado verdadeiro ou falso será */

/* armazenado na variável transportadora */

bool transportadora = ((código == 10) && (tipo == “T”));

Operador = Atribui um valor à uma variável.

Exemplo: x = 1 // x recebe valor 1

Note que para testar uma condição utiliza-se “dois iguais” (==) e para atribuir utiliza-se apenas “um igual” (=)

Operador += Efetua a soma de uma variável. Uma representação x += 3 é idêntica à x = x + 3

Operador -= Efetua a subtração de uma variável. Uma representação x -= 4 é idêntica à x = x - 4

Comando If If é utilizado para testar uma condição verdadeira ou falsa

bool result = true;

if (result)

{

Console.WriteLine("A variável é verdadeira");

}

else

{

Console.WriteLine("A variável é falsa");

}

Ou

if (result)

Console.WriteLine("A variável é verdadeira");

else

Console.WriteLine("A variável é falsa");

Nesta última sintaxe sem as chaves {} o else refere-se sempre ao último if sem else. A instrução anterior ao else é fechada com ponto-e-vírgula “;”.

Comando for O loop "for" trabalha checando uma condição para executar um bloco de código até que

essa condição seja verdadeira, no caso do loop "for" temos que em sua sintaxe declarar

sua inicialização, sua condição e seu incremento.

Exemplo: for (int i =0; i <= 10; i++)

{

//instruções

}

No código acima temos a sintaxe de um loop "for" onde na primeira parte declaramos uma variável do tipo inteiro (int) e a inicializamos com o valor 0 (zero), na segunda parte temos a condição nesse caso verifica se a nossa variável recém criada é menor ou igual a 10 e a terceira e ultima parte é o incremento desta variável, sendo essas três partes separadas por ";" (ponto e virgula). O funcionamento é simples todo o código dentro desse bloco do "for" será executado dez vezes

Comando while De modo diferente do loop "for" (embora o objetivo seja o mesmo, ou seja, repetir a execução de um código testando uma condição) o loop "while" é mais simples de ser entendido, pois sua sintaxe não requer que você coloque na mesma linha variável de inicialização, condição e o seu incremento. No loop "while" apenas colocamos a condição que queremos testar.

Sintaxe: while (expressão booleana)

{

//instruções

}

Veja como é simples o código. Expressão booleana é uma expressão que sempre retorna falso ou verdadeiro e a instruções dentro do bloco de código do loop "while" só será executada enquanto essa expressão retornar verdadeiro.

Exemplo: int contador = 2;

while (contador != 10)

{

Console. WriteLine (contador.ToString());

contador++;

}

Comando foreach O loop "foreach" é usado para interagir (percorrer) listas. Ele opera sobre Arrays ou coleções veja sua syntax básica:

foreach(<tipo de dado> <nome> in <lista>)

{

//instruções

}

Exemplo: string[] nomes = {"Cleber", "Carol", "Denis", "Roberto"};

foreach (string pessoa in nomes)

{

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

}

Criamos um array de string e colocamos alguns elementos dentro e no nosso loop "foreach" será exibida todos os elementos dentro de nosso array.

Arrays Arrays é uma coleção de objetos do mesmo tipo armazenados seqüencialmente na

memória e identificados através de um índice. Toda array no .NET tem a propriedade

Length que determina o tamanho da array.

// declara um array de 3 elementos inicializando os valores

// os elementos são separados por vírgulas na inicialização

int[] numbers = { 34, 42, 55 };

// este exemplo é igual ao anterior, só que em duas linhas

int[] numbers;

numbers = new int[] { 34, 42, 55 };

// declara um array do tipo int de tamanho desconhecido

int[] numbers;

// determina o tamanho do array em 10 elementos indexados de 0 à 9

numbers = new int[10];

// determina o tamanho do array em 20 elementos indexados de 0 à 19

numbers = new int[20];

// attribui o valor 2 para o primeiro elemento (índice 0) da array

numbers[0] = 2;

// attribui o valor 4 para o segundo elemento (índice 1) da array

numbers[1] = 4;

// percorre todos os elementos da array

// a propriedade Length auxilia a determinar a

// quantidade de elementos da array

int total = 0;

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

total += numbers[i];

Generics Generic é uma espécie de polimorfismo, permitindo a criação de “templates” e

qualquer classe pode ser filho de um template dinamicamente, ou seja, em tempo real

sem a necessidade de formalidade na declaração.

List<T> Onde List<> é um template, neste caso um array dinâmico cujos

elementos são objetos da classe T

Exemplo 1: List<string> list = new List<string>();

list.Add(“teste1”);

list.Add(“teste2”);

list.Add(“teste3”);

Exemplo 2: public class Produto

{

private string codigo;

public string Codigo

{

get { return codigo; }

set { codigo = value; }

}

}

List<Produto> list = new List<Produto>();

list.Add(new Produto());

list.Add(new Produto());

list.Add(new Produto());

list[0].Codigo = “0101”;

list[1].Codigo = “0202”;

list[2].Codigo = “0303”;

No primeiro exemplo, a lista foi populada com 3 strings diretamente pelo método Add.

No segundo exemplo, a lista foi populada com 3 objetos do tipo Produto e todos os

elementos da lista também são do tipo produto. Ao tentar executar neste exemplo um

Add com uma string, um erro ocorrerá na compilação do código.

Tratamento de erros Quando uma instrução produz um erro, dizemos que houve um “estouro” de um erro

ou exceção. Todos os erros do Microsoft.NET são filhos da classe Exception e por

convenção tem o sufixo “Exception”.

Ex: OutOfMemoryException, DivideByZeroException e Exception.

Para tratar um erro no C#, usamos a seguinte sintaxe:

try { <instruções> }

catch (Exception ex) { <instruções> }

finally { <instruções> }

ONDE:

try Bloco de instruções onde pode ocorrer um erro

catch (Exception ex) Bloco de instruções responsável por tratar o erro Exception ou

qualquer erro filho de Exception. Este bloco é opcional

finally Bloco de instruções executado em qualquer situação, ocorrendo

erro ou não. Aqui são desalocados todos os recursos alocados e

executados o método Dispose dos objetos

Se as instruções não estiverem envolvidas por try/catch/finally, o erro é estourado no

método anterior a estas instruções. Se mesmo assim não houver um try/catch/finally o

erro é estourado no método anterior até encontrar a instrução try/catch/finally. Se

todos os métodos não contém try/catch/finally, ocorre um “erro fatal” e a aplicação é

finalizada inesperadamente.

OU SEJA:

try

{

// Instruções C# passíveis de erro

}

catch (NumericOverflowException ex)

{

/*

As instruções aqui são executadas quando

ocorrer um erro no bloco try do tipo NumericOverflowException

que não tenha sido tratado anteriormente

Neste ponto pode-se exibir uma mensagem ou registrar um log

*/

}

catch (Exception ex)

{

/*

As instruções aqui são executadas quando houver

ocorrer um erro no bloco try do tipo Exception

que não tenha sido tratado anteriormente

Neste ponto pode-se exibir uma mensagem ou registrar um log

*/

}

finally

{

/*

As instruções aqui são executadas após o bloco try.

Se houver qualquer tipo de erro no bloco try,

este bloco é executado imediatamente após o erro

Se não houver qualquer tipo de erro,

Este bloco é executado imediatamente após o término de try

Esta é a melhor oportunidade para desalocar a memória

Aproveite e execute o método Dispose dos objetos,

Pois ele é encarregado de liberar os recursos para o SO

*/

}

Acesso a banco de dados No Microsoft.NET há várias maneiras de acessar dados, podemos utilizar ODBC,

OLEDB, Connector. A conexão mais comum é por OLEDB.

OLEDB OleDbConnection Responsável por manter uma conexão com o banco de

dados

OleDbCommand Responsável por manipular strings SQL e seus parâmetros

OleDbDataReader Responsável por ler dados retornados por uma string SQL

Exemplo:

public class Saldo

{

public void AtualizaSaldo(int produtoId, double quantidade)

{

OleDbConnection cnn = null;

OleDbCommand cmd = null;

try

{

cnn = new OleDbConnection();

cnn.ConnectionString = “Provider=Microsoft.Jet.OLEDB.4.0;Data

Source=c:\\dados.mdb”;

cnn.Open();

cmdAtualizaEstoque = new OleDbCommand();

cmdAtualizaEstoque.Connection = cnn;

cmdAtualizaEstoque.CommandText =

“UPDATE SET qt_saldo=qt_saldo+? WHERE id_produto = ?”;

cmdAtualizaEstoque.Parameters.AddWithValues(

“@quantidade”, quantidade);

cmdAtualizaEstoque.Parameters.AddWithValues(

“@id_produto”, produtoId);

cmdAtualizaEstoque.ExecuteNonQuery();

cnn.Close();

}

finally

{

if (cnn != null) cnn.Dispose();

if (cmd != null) cmd.Dispose();

}

}

}

Neste exemplo, os parâmetros são identificados na string por ? (ponto de interrogação), ou por @nomedoparametro. Seus valores são passados através do método Parameters.AddWithValues na mesma ordem que aparecem na SQL. Nota-se que se houver qualquer erro na execução, a conexão é fechada e os recursos de banco de dados são desalocados da memória. ExecuteNonQuery indica que o comando não retorna dados, apenas executa uma operação de atualização, uma stored procedure ou qualquer comando que não retorno linhas ou colunas. ExecuteReader indica que o comando retorna linhas e colunas, para tanto é necessário um objeto OleDbDataReader para percorrer seus valores. ExecuteScalar indica que o comando retorna apenas uma linha e uma coluna. Ideal para executar operações do tipo SELECT SUM(), ou SELECT COUNT() ou SELECT MAX(). Se mais linhas ou colunas retornarem todas serão ignoradas.

public List<Produto> Consultar()

{

OleDbConnection cnn = null;

OleDbCommand cmd = null;

OleDbDataReader rdr = null;

try

{

cnn = new OleDbConnection();

cnn.ConnectionString =

“Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\\dados.mdb”;

cnn.Open();

cmd = new OleDbCommand();

cmd.Connection = cnn;

cmd.CommandText =

“UPDATE SET qt_saldo=qt_saldo+? WHERE id_produto = ?”;

cmd.Parameters.AddWithValue(“@quantidade”, quantidade);

cmd.Parameters.AddWithValue(“@id_produto”, produtoId);

List<Produto> list = new List<Produto>();

rdr = cmd.ExecuteReader();

while (rdr.Read())

{

Produto p = new Produto();

p.Codigo = rdr[“id_produto”].ToString();

p.Descricao = rdr[“ds_produto”].ToString();

list.Add(p);

}

cnn.Close();

return list;

}

finally

{

if (rdr != null) rdr.Dispose();

if (cmd != null) cmd.Dispose();

if (cnn != null) cnn.Dispose();

}

}

Neste exemplo, os parâmetros são identificados na string por ? (ponto de interrogação), ou por @nomedoparametro. Seus valores são passados através do método Parameters.AddWithValues na mesma ordem que aparecem na SQL. Nota-se que se houver qualquer erro na execução, a conexão é fechada e os recursos de banco de dados são desalocados da memória.

Leitura e gravação de arquivos textos Para ler ou gravar um arquivo texto, é necessário utilizar as classes: StreamReader Utilizado para leitura de um arquivo texto StreamWriter Utilizado para a gravação de um arquivo texto StreamReader e StreamWriter podem gravar arquivos do tipo ANSI ou UNICODE de acordo com o parâmetro Encoding. Encoding.UNICODE Tipo de arquivo UNICODE Encoding.UTF8 Tipo de arquivo UTF8 Encoding.UTF7 Tipo de arquivo UTF7 Encoding.Default Tipo de arquivo ANSI e PAGE CODE do sistema

Operacional

Exemplo de leitura de um arquivo texto: public List<Produto> Consultar()

{

StreamReader reader = null;

try

{

reader = new StreamReader(“c:\\produtos.txt”);

string line = reader.ReadLine();

while (line != null)

{

string[] values = line.Split(“;”);

line = reader.ReadLine();

string codigo = values[0];

string descricao = values[1];

MessageBox.Show(

“Código “ + código

“ Descrição” + descricao);

}

}

finally

{

if (reader != null) reader.Dispose();

}

}

Exemplo de gravação de arquivo texto: public void Salvar(string[] values)

{

StreamWriter writer = null;

try

{

writer = new StreamWriter(“c:\\produtos.txt”);

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

writer.WriteLine(values[i]);

writer.Close();

}

finally

{

if (writer != null) writer.Dispose();

}

}

Databind Os controles visuais no .NET permitem serem populados manualmente, através de seus métodos e propriedades, ou integrados diretamente com uma fonte de dados. Quando um controle não possui uma fonte de dados e é populado manualmente, chamamos de controle Unbounded. Quando há uma fonte de dados para popular automaticamente, chamados de controle Bounded. Uma fonte de dados pode ser uma Coleção, Lista, DataTable, DataSource. Exemplo 1: public class Produto

{

private string _codigo;

public string Codigo

{

get { return _codigo; }

set { _codigo = value; }

}

private string _nome;

public string Nome

{

get { return _nome; }

set { _nome = value; }

}

}

public class Form1: Form

{

protected void Form_Load(object sender, EventArgs e)

{

List<Produto> list = new List<Produto>();

list.Add(new Produto());

list.Add(new Produto());

list.Add(new Produto());

list[0].Codigo = “1010”;

list[0].Nome = “BACIA TIPO 1”;

list[1].Codigo = “1020”;

list[1].Nome = “BACIA TIPO 2”;

list[2].Codigo = “1030”;

list[2].Nome = “BACIA TIPO 3”;

// Controle unbounded

ComboBox cmb1 = new ComboBox();

for (int i = 0; i < list.Count; i++)

cmb1.Items.Add(list[i].Nome);

Controls.Add(cmb1);

// Controle bounded

ComboBox cmb2 = new ComboBox();

cmb2.DisplayMember = “Nome”;

cmb2.ValueMember = “Codigo”;

cmb2.DataSource = list;

Controls.Add(cmb2);

}

}

No controle Unbounded , a combobox foi populada manualmente. Todos os valores

adicionados através de cmb1.Items.Add serão exibidos na combobox.

No controle Bounded, a combobox recebe uma lista de valores através da propriedade

DataSource. DisplayMember define qual das propriedades contém o valor único (ou o código)

do objeto. TextMember define qual das propriedades contém os valores exibidos na lista da

combobox. Quando um item é selecionado, a propriedade SelectedValue contém o valor da

propriedade definida em ValueMember.

Em vez de uma lista, o DataSource pode receber um DataTable, DataSource, ou qualquer

objeto que contenha dados.