C# - Algoritmos de ordenação de dados

Os algoritmos de ordenação de dados podem parecer um assunto acadêmico mas na verdade esta presente a todo momento em nossas vidas e nos sistemas que desenvolvemos. Muitas vezes as linguagens atuais trazem recursos que permitem que com um único comando seja feita a ordenação de uma estrutura de dados e muitas vezes não nos percebemos da importância que esta por trás disso.

Meu objetivo neste artigo é apresentar os principais algoritmos de ordenação para que possamos estudá-los e compreendê-los melhor.

Vou apresentar os seguintes algoritmos :

1. Inserção2. BubbleSort3. QuickSort4. MergeSort5. ShellSort

Antes de iniciar a parte prática vamos a um pouco de teoria...

O algoritmo de ordenação por inserção

Comecei por este por ser o mais simples e intuitivo; ele é baseado em ações que praticamos no dia dia para realizar ordenações simples com um pequeno número de elementos.

O algoritmo de ordenação por inserção é muito eficiente quando aplicado a um pequeno número de elementos e funciona assim:

- Percorre-se um vetor de elementos da esquerda para a direita e à  medida que se avança se vai deixando os elementos mais à esquerda ordenados.(Inseridos no final do vetor);

Este método é exatamente o que usamos quando temos algumas cartas de baralho para ordenar.

Uma implementação simples deste algoritmo necessita de duas estruturas de listas : a lista fonte e a lista na qual os itens são inseridos ordenados.

Este algoritmo é mais eficiente que o Bubble Sort e que o algoritmo Selection Sort e pode ser usado com eficácia para ordenações de até 1000 itens.

Vejamos a seguir sua implementação na linguagem C# e em VB .NET:

static int[] ordernar(int[] A){int i, j, index;for (i = 1; i < A.Length; i++){index = A[i];j = i;while ((j > 0) && (A[j - 1] > index)){A[j] = A[j - 1];j = j - 1;}A[j] = index;}return A;} 

 Private Sub Ordenacao(Numeros() As Integer)       Dim i As Long       Dim j As Long       Dim iMin As Long       Dim iMax As Long       Dim varSwap As Variant       iMin = LBound(Numeros) + 1       iMax = UBound(Numeros)       For i = iMin To iMax           varSwap = Numeros(i)           For j = i To iMin Step -1               If varSwap < Numeros(j - 1) Then Numeros(j) = Numeros(j - 1) Else Exit For           Next j          Numeros(j) = varSwap       Next iEnd Sub 

Algoritmo de ordenação por inserção

Esse algoritmo, como muitos outros, é baseado em ações que nós (como pessoas) fazemos no dia-a-dia para resolver o problema. Lembra quando você está jogando baralho, e suas cartas já estão na mesa e você precisa colocá-las na mão de uma forma ordenada? Essa ordenação deve ser feita de uma maneira que você esteja acostumado a escolher uma carta facilmente para jogar mais rápido e melhor... É exatamente isso que o algoritmo de ordenação por inserção faz por baixo dos panos. A idéia principal dele é: adiciona-se um item qualquer à estrutura de dados, depois, para cada item que ainda não esteja na estrutura, antes de adicioná-la, comparar com cada item que já está nela (consequentemente já ordenada) até encontrar a posição a ser encaixada. É exatamente o que fazemos com o baralho. Essa opção é boa quando temos uma entrada pequena de dados, para entradas grandes pode se consumir muito tempo de processamento.

--------

Insertion sort, ou ordenação por inserção, é um simples algoritmo de ordenação, eficiente quando aplicado a um pequeno número de elementos. Em termos gerais, ele percorre um vetor de elementos da esquerda para a direita e à medida que avança vai deixando os elementos mais à esquerda ordenados. O algoritmo de inserção funciona da mesma maneira com que muitas pessoas ordenam cartas em um jogo de baralho como o pôquer.[1]

 

a

Algoritmo Bubblesort

Talvez um dos mais populares dos algoritmos para ordenação seja o bubblesort, isso pela fácil memorização de como funciona e como é fácil a sua implementação. Ele consiste basicamente em intercalar elementos, por isso se enquadra na categoria de

ordenação por intercalação, a implementação dele é simples. Com uma estrutura de dados desordenada inicia-se o algoritmo pelo primeiro elemento, depois faz-se a comparação dele com todos os que estão depois dele na estrutura desordenada, portanto com 4 linhas de código dá para se implementar.

a

Algoritmo Mergesort 

Um algoritmo bem interessante por alguns motivos. Esse é um algoritmo que segue uma técnica de dividir para conquistar na base de sua idéia principal. O raciocínio básico para que ele funcione é o seguinte: ordenar uma estrutura significa ordenar várias subestruturas internas já ordenadas, caso essas estruturas não estejam ordenadas, basta ordená-las pelo mesmo método (ordenar suas subestruturas internas... até o infinito), é um algoritmo com uma base bem matemática e com um método bem interessante para estudo. Como a idéia pode não ter ficado bem clara vou mostrar um exemplo: ordenar 6, 3, 4, 8, 1, 2, 3, 5... o algoritmo irá dividir em pares ordenados: {3,6}, {4,8}, {1,2}, {3,5}, depois ir fazendo o merge desses dados, ou seja, juntando-os em dois pares ordenados: {3,4,6,8}, {1,2,3,5}, depois juntar novamente: 1,2,3,3,4,5,6,8. No final do algoritmo a seqüência inicial está ordenada a partir de divisões... Por sua base bem estruturada esse algoritmo tem tempo médio bem rápido.

a

Algoritmo Heapsort

Esse algoritmo tem tempo de execução de um algoritmo de ordenação por intercalação, e faz as suas operações localmente, sempre apenas um número constante de elementos é armazenados fora da estrutura de dados, como é feito o algoritmo por inserção. Mas o que ele tem de interessante é a forma que ele arranja os dados para depois ordená-los, ele utiliza uma estrutura chamada de heap ou monte, que é uma arvore binária que é extremamente importante para vários conceitos e problemas computacionais, pois depois de ordenados os dados, podemos, por exemplo, saber em que nível da árvore se encontra determinado item, operações sobre arvores binárias são conceitos muito importantes para outras estruturas como grafos.

a

Algoritmo de ordenação por contagem

Esse algoritmo pode ser o mais rápido em vários casos, pois ele ordena os dados em tempo linear, sim, tempo linear é possível. Essa ordenação pressupõe que os dados serão sempre uma entrada de 1 a n, para qualquer inteiro n, ou seja, se terão 6 dígitos, a entrada precisa ser qualquer combinação possível de 6 números que variam entre si de um a 6.

A base matemática do algoritmo está em determinar para cada elemento x de entrada o número de elementos menores que x, e depois inserir diretamente x na posição de saída na estrutura.

Existem diversos outros algoritmos importantes, como quicksort, radix sort, bucket sort, e outros mais... Coloquei apenas os que mais acho importante para se fazer com características diferentes em determinadas ocasiões. 

O importante, como sempre, é saber o que utilizar e quando utilizar, para um melhor desempenho, lembrando também que a forma como é implementado cada algoritmo pode influenciar diretamente no desempenho do mesmo e um algoritmo dito mais rápido, pode ficar mais lento.

a

Criado por Donald Shell em 1959[1], publicado pela Universidade de Cincinnati, Shell sort é o mais eficiente algoritmo de classificação dentre os de complexidade quadrática. É um refinamento do método de inserção direta.[2] O algoritmo difere do método de inserção direta pelo fato de no lugar de considerar o array a ser ordenado como um único segmento, ele considera vários segmentos sendo aplicado o método de inserção direta em cada um deles.[3] Basicamente o algoritmo passa várias vezes pela lista dividindo o grupo maior em menores. Nos grupos menores é aplicado o método da ordenação por inserção.

a

Até o próximo artigo C#...

Referências:

   

José Carlos Macoratti

C# - Verificando a conexão e abrindo uma página web

Para verificar se existe uma conexão ativa com a internet podemos usar a função InternetGetConnectedState da APi Win32.

Essa função recebe dois parâmetros.

O primeiro será preenchido com informações sobre a conexão; O segundo é reservado, devemos passar o valor 0 nesse

parâmetro;

A função retorna TRUE indicando se existe uma conexão ou modem ativo, ou FALSE se não existir conexão ou se todas as conexão não estão ativas.

O namespace System.Runtime.InteropServices fornece uma ampla variedade de membros que suportam a interoperabilidade e a invocação de serviços da plataforma sendo que  é através desse namespace que usamos o atributo DllImport para definir os métodos de invocação da plataforma para acessar as APIs de código não gerenciado (COM).

Quando você utiliza uma DLL externa via DllImport, o .NET chama a API do Windows chamada LoadLibrary; essa API é responsável por localizar a sua DLL no computador e carregá-la na memória...

A LoadLibrary, procura em diferentes lugares, usando a seguinte ordem:

1. Na pasta onde está o executável da aplicação;2. Na pasta padrão do sistema (C:\Windows\System32)3. Na pasta padrão onde está instalado o Windows (C:\Windows)4. Na pasta a partir de onde a aplicação foi executada;

Dessa forma, se a sua DLL estiver em qualquer destes locais, ela será encontrada, e executada...

Fique atento portanto para possíveis versões diferentes da mesma DLL em arquivos com o mesmo nome mas em lugares diferentes, pois desta forma o DllImport vai executar a primeira que achar.

A classe Process fornece acesso a processos locais e remotos e permite iniciar e interromper processos do sistema local.

Um componente Process fornece acesso a um processo que esta sendo executado no computador. Um processo nada mais é que uma aplicação que esta sendo executada. A thread é a unidade básica na qual o Sistema Operacional aloca o tempo de processamento e pode executar qualquer parte do código de um processo.

O Componente Process é uma ferramenta útil para iniciar, parar, controlar e monitorar aplicações, e, através do seu uso podemos obter uma lista de processos que estão rodando, ou iniciar um novo processo.

O método Start() , inicia ou reutiliza um processo que esta sendo definido na propriedade StartInfo do componente Process e o associa a este componente.

O método sobrecarregado Start('string') inicia um processo definido pelo nome do documento ou aplicação através da associação dos recursos com o componente Process.

Abra o Visual C# 2010 Express Edition e crie um novo projeto do tipo Windows Application com o nome VerificandoConexaoWeb;

No formulário padrão form1.cs inclua um controle LinkLabel conforme o leiaute abaixo:

A seguir defina os seguintes namespaces que vamos usar no projeto:

using System.Runtime.InteropServices;using System.Diagnostics;

Agora no formulário form1.cs defina as seguintes rotinas:

//Método da API[DllImport("wininet.dll")]private extern static Boolean InternetGetConnectedState(out int Description, int ReservedValue);

// Um método que verifica se esta conectadopublic static Boolean IsConnected(){   int Description;   return InternetGetConnectedState(out Description, 0);} 

No evento Click do controle LinkLabel defina o seguinte código:

private void linkLabel1_Click(object sender, EventArgs e){

// Se a internet esta conectada  if (IsConnected())  {     Process mProcesso = new Process();      // indica se deve usar o shell do sistema     // operacional para iniciar o processo    mProcesso.StartInfo.UseShellExecute = true;    // podemos iniciar qualquer processo    mProcesso.StartInfo.FileName = "http://www.macoratti.net";    // indica se o processo deve iniciar em uma nova janela    mProcesso.StartInfo.CreateNoWindow = true;    mProcesso.Start();

    //outra forma direta de chamar a página seria   //System.Diagnostics.Process.Start("http://www.macoratti.net");  }   else  {      MessageBox.Show("Não exite conexão ativa com a internet.");  }} 

Executando o projeto e clicando no LinkLabel a página será aberta em uma nova janela.

Até o próximo artigo C#...

Pegue o projeto completo aqui: VerificandoConexaoWeb.zip

Referências:

VB.NET - Chamando Windos API Usando API no Visual Basic

José Carlos Macoratti

C#  - Tradutor Rápido para consultas

Que tal um tradutor rápido para consultas  ???

Esta singela aplicação feita na linguagem C# utiliza diversas API´s Open Source como as ferramentas de idioma on-line do Google e pode ser instalada na sua máquina local ficando ativa na barra de tarefas.

Permite traduzir pequenos textos para diversos idiomas bem como copiar o resultado para a área de transferência (Clipboard).

Defina o idioma de origem e o de destino, informe o texto e pronto a tradução é automática.

Enfim um projeto interessante para uso e estudo. As possibilidades são ilimitadas...

Pegue o projeto completo aqui: TradutorRapido.zip (1.5 MB)

Eu sei é apenas C#, mas eu gosto...

Referências:

Super DVD .NET - Dezenas de sistema com fontes na linguagem VB .NET e C#.

José Carlos Macoratti

C# - 10 dicas para otimizar o seu código

A otimização do código de uma aplicação é um aspecto importante que contribui para melhorar o desempenho e a eficiência.

A seguir temos 10 dicas rápidas, mas importantes, que quando aplicadas ao seu dia dia ajudam a otimizar o código de sua aplicação C#.

1- Utilizando o StringBuilder de forma adequada

O objeto String é imutável e cada vez que você usa um dos métodos da classe System.String você cria um novo objeto string na memória que requer uma nova alocação de espaço para o novo objeto.

Em situações onde você precisa realizar repetidas modificações em um string, a criação de um novo objeto String tem um custo elevado.

Ai entra o objeto StringBuilder, você já deve saber que o objeto StringBuilder é muito mais rápido para concatenar strings principalmente quando temos strings grandes.

Dessa forma se você tem que concatenar strings em um laço com muitas iterações a classe System.Text.StringBuilder é imbatível.

Mas atenção, se você pretende concatenar apenas uma única string então ao invés de usar o StringBuilder de preferência ao tipo String simples; nestes casos usar strings é mais recomendado:

Para strings grandes ou operações repetidas com strings ao invés de usar:

  string msg;  msg = msg + "macoratti.net";

  msg = msg + "Otimize seu código C#";  msg = msg + " ......";  msg = msg + " ......";  msg = msg + "Utilizando o StringBuilder";

prefira usar:

  StringBuilder msg = new StringBuilder();     msg.Append("macoratti.net ");  msg.Append("Otimize seu código C# ");  msg = msg + " ......";  msg = msg + " ......";  msg.Append("Utilizando o StringBuilder ");  mas para operações simples com strings não use StringBuilder prefira usar strings:

  string msg;  msg = msg + "macoratti.net";

2- Comparando Strings Non-Case-Sensitive

Muitas vezes temos que comparar duas variáveis strings, sem considerar o case sensitive. O recurso mais usado é converter ambas as strings para caixa baixa (minúsculas) ou caixa alta (maiúsculas) e então comparar as duas strings da seguinte forma:

str1.ToLower() == str2.ToLower()

Porém usar repetidamente a função ToLower() afeta o desempenho.

Uma escolha melhor é usar a função string.Compare() .

Assim podemos fazer:

string.Compare(str1, str2, true) == 0

A função string.Compare() retorna um inteiro que é igual a 0 quando as duas strings forem iguais.

3- Utilize String.Empty ao invés de ""A sugestão em usar string.Empty não é tanto pelo fator desempenho mas para facilitar a leitura e entendimento do seu código.

Ao invés de usar:

if (str1 == "")

prefira usar:

if (str1 == string.Empty)

É uma boa prática de programação e não causa um impacto negativo no desempenho da aplicação.

4- Prefira utilizar List<> a ArrayListUm ArrayList é útil quando desejamos armazenar mais de um tipo de objeto em uma mesma lista. Porém se desejamos tratar o mesmo tipo de variável em um ArrayList podemos ter um desempenho melhor usando a classe List<>.

Dessa forma no código abaixo:

ArrayList intLista = new ArrayList();intLista.add(10);return (int)intLista[0] + 20;

Temos que a nossa lista contém apenas inteiros. Neste caso usar a classe List<> é muito melhor. Para convertê-la para uma lista tipada, somente os tipos das variáveis necessitam ser alterados;

List<int> intLista = new List<int>();intLista.add(10)return intLista[0] + 20;

Não precisamos realizar uma conversão forçada (cast) com List<>.

O aumento do desempenho pode ser especialmente significativo com dados primitivos como Integers.

5- Utilize os operadores && e || ao invés de & e |Ao tratar com instruções if no seu código, utilize os operadores && e || com dupla notação (AndAlso e OrElse no Visual Basic).

Instruções if que usam & e | preciam verificar cada parte da instrução e então aplicar o 'and' ou 'or'.

Ao usar && e || o compilador percorre a instrução somente uma única vez e para assim que a condição foi verificada verdadeira ou falsa.

Considere o seguinte código:

if (object1 != null && object1.runMethod())

Se o object1 é nulo , com o operador &&,  object1.runMethod() não será executado.

Se o operador usado for &, object1.runMethod() será executado mesmo se  object1 for nulo, causando um exceção.

6- Use o bloco Try-Catch ao invés de ifO bloco Try-Catch é usado para capturar exceções que vão além do controle do programado, como conexões com banco de dados ou dispositivos de rede.

Então dê preferência a usar o  bloco Try-Catch para capturar exceções ao invés de usar instruções if.

static void Main() {   int x;   try    {      // Não inicialize a variável aqui

      x = 123;   }   catch   {   }    // Erro: Uso de uma variável local não atribuída    Console.Write(x);}

No interior de um bloco try somente inicialize uma variável que for declarada dentro do bloco, de outra forma poderá ocorrer uma exceção antes que execução do bloco terminar. O exemplo acima mostra isso.

7- Substitua operações de divisão por shift/MultiplicaçãoO C# é lento com operações de divisão, uma alternativa é substituir essas operações pela utilização do operador Shift e uma operação de multiplicação.

Exemplo:

x = num / div;   

Deve ser substituído por:

        x = (num * mul) >> shift;

O operador de multiplicação e o operador shift é mais rápido que a divisão.

Assim outras operações como mod também podem ser otimizadas usando o mesmo princípio:

x = num % div;   é igual a  x = num - (num/div) * div;

que deve ser substituído por:

x = num - ((num * mul) >> shift) * div;

8- O Laço for é mais rápido que laço foreachPrefira usar um laço for a um laço foreach.

Ao invés de usar:

static private void TestForeachLoop(ArrayList List){   int id = 0;

   foreach (int i in List)   {      // processamento...     id = i;    }}laço foreach é mais lento

 Prefira usar:

static private void TestForLoop(ArrayList List){    int id = 0;    int count = List.Count;

    for (int i = 0; i < List.Count; i++)    {       // processamento...       id = (int)List[i];    }}laço for é mais rápido

9 - Heap x Stack. Stack é mais rápido.A alocação de memória para estruturas(Stack) é muito mais rápida que alocação de memória para Classes(Heap).

Quando  possível evite criar objetos e usar classes prefira usar os tipos primitivos e estruturas. (quando possível...)

10 - String.Equals é melhor que == O  operador == é fortemente tipada e somente será compilado se ambos os parâmetros forem strings oque implica que não há necessidade de realizar conversão.

String.Equals possui múltiplas sobrecargas, uma delas é fortemente tipada, e, dependendo da versão que você chama você pode pagar um custo por isso

Obs: Para comparar strings ,que são valores por referência, use String.Equals. Ex: string.Equals(s1, s2)

São 10 dicas simples mas que se usadas sistematicamente tornam o seu código mais eficiente e rápido.

C# , Simples, simples assim...

Referências:

ADO.NET - Boas Práticas de Programação

Jos C# - Trabalhando com Threads

Neste artigo volto a falar sobre threads desta vez usando a linguagem C#.

O que é uma thread (Linha de execução) ?

Vejamos algumas definições:

Linha de execução (em inglês: Thread), é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas concorrentemente. O suporte à thread é fornecido pelo próprio sistema operacional (SO), no caso da linha de execução ao nível do núcleo (inglês: Kernel-Level Thread (KLT)), ou implementada através de uma biblioteca de uma determinada linguagem, no caso de uma User-Level Thread (ULT).

Uma linha de execução permite que o usuário de programa, por exemplo, utilize uma funcionalidade do ambiente enquanto outras linhas de execução realizam outros cálculos e operações.http://pt.wikipedia.org/wiki/Thread_(ci%C3%AAncia_da_computa%C3%A7%C3%A3o)

"Uma Thread é Um fluxo de controle sequencial isolado dentro de um programa" Como um programa sequencial qualquer, um thread tem um começo, um fim, e uma seqüência de comandos. Entretanto, um thread não é um

programa, não roda sozinho, roda dentro de um programa. Threads permitem que um programa simples possa executar várias tarefas diferentes ao mesmo tempo, independentemente umas das outras. Programas multi-threaded são programas que contém vários threads, executando tarefas distintas, ao mesmo tempo. Threads, sequências, linhas de execução, encadeamento não importa o nome , todas as aplicações são executadas em uma thread principal. Uma aplicação pode ter mais de uma thread ao mesmo tempo, ou seja, podemos estar fazendo várias coisas ao mesmo tempo, quer um exemplo ? O sistema operacional Windows. A barra de tarefas exibe os processos que estão sendo executados simultaneamente. Não se iluda , embora você esteja vendo a barra de tarefas (Task Manager) exibir diversos aplicativos sendo executados , nenhum deles esta sendo executado ao mesmo tempo. Não existe computador que possa realizar esta proeza com uma única CPU. O que o Windows , e qualquer outro aplicativo que suporte a multitarefa , faz é estar alternando rapidamente entre diferentes threads de forma que cada thread pensa que esta executando independentemente, mas, só executa por algum tempo, interrompe e depois volta, e assim por diante.

A linguagem C# suporta a execução paralela de código através do multithreading onde uma Thread é uma caminho de execução independente que esta apto para rodar simultaneamente com outras threads.

Um programa C# quer do tipo Console, WPF ou Windows Forms inicia em uma única thread criada de forma automática pela CLR (Common Languagem Runtime) e pelo Sistema Operacional ( a thread principal - main ) e torna-se multithread pela criação de threads adicionais.

Vamos iniciar criando um thread simples na linguagem C# . Estou usando o Visual C# 2010 Express Edition e em todos os exemplos estou usando o namespace:

using System.Threading;

Abra o Visual C# 2010 Express e crie um novo projeto do tipo Console chamado UsandoThreads_1 com o seguinte código:

using System;using System.Threading;

namespace UsandoThreads_1{    class Program    {        static void Main(string[] args)        {            // dispara uma nova thread para executar             Thread t = new Thread(NovaThread);                      t.Start();                              

            // Simultaneamente, executa uma tarefa na thread principal            for (int i = 0; i < 10000; i++) Console.Write("1");        }

        static void NovaThread()        {            for (int i = 0; i < 10000; i++) Console.Write("2");        }    }}

A Neste singelo programa a thread principal cria uma nova thread t a qual roda um método que imprime na tela o numero 2 (segunda thread);

Simultaneamente a thread principal imprime o número 1 (thread principal).

Observe que a thread principal inicia e já cria a segunda thread que começa a imprimir o número 2, após isso a execução é intercalada e ocorre simultaneamente exibindo o resultado da figura mostrada ao lado do código.

O método Start() inicia a execução da segunda thread e após o término da execução ambas as threads são encerradas.

Abaixo temos uma figura que resume o comportamento da execução do programa:

Uma vez iniciada pelo método Start() a propriedade IsAlive da thread retorna true até que a thread seja encerrada.

Nota: A propriedade IsAlive obtém um valor que indica o status de execução do thread corrente. O valor true indica que a thread foi iniciada e não foi terminada.

Uma thread termina quando o delegate passado para o construtor da thread encerra a execução e uma vez terminada uma thread não pode ser re-iniciada.

A CLR atribui a cada thread sua própria alocação de memória na pilha (Stack) de forma que variáveis locais são mantidas separadas.

Vejamos agora um exemplo onde definimos um método com uma variável local e então chamamos o método simultaneamente na thread principal e na nova thread criada;

Crie um novo projeto do tipo console com o nome UsandoThreads_2 e defina o seguinte código no programa:

using System;using System.Threading;

namespace UsandoThreads_2{    class Program

Neste código estamos criando uma nova thread e chamando a rotina NovaThread;

Em seguida chamamos novamente a rotina NovaThread na thread principal;

    {        static void Main(string[] args)        {            // Chama NovaThread em uma nova Thread            new Thread(NovaThread).Start();                  // Chama NovaThread na thread principal            NovaThread();            Console.ReadKey();        }

        static void NovaThread()        {            //Declara e usa a variável local - contador            for (int contador = 0; contador < 5; contador++)                   Console.Write('2');        }    }}

A rotina NovaThread declara e usa uma variável local chamada contador;

Uma cópia separada da variável contador é criada e cada thread aloca a área de memóriaStack para a variável;

Dessa forma o resultado da execução é o seguinte:

A threads podem compartilhar dados se eles tiverem uma referência comum para a mesma instância. Veja o exemplo a seguir:

Crie um novo projeto do tipo console com o nome UsandoThreads_3 e defina o seguinte código no programa:

using System;using System.Threading;

namespace UsandoThreads_3{    class Program    {        bool ok;

        static void Main(string[] args)        {

Agora estamos criando uma instância comum , iniciando uma nova thread,onde estamos executando a rotina NovaThread, e, em seguida executamosnovamente a mesma rotina na mesma instância.

Como estamos usando a mesma instância iremos obter o mesmo resultadoconforme exibido a seguir:

            // Cria uma instância comum            Program tt = new Program();               //inicia a execução da rotina na nova instância             new Thread(tt.NovaThread).Start();            //executa a rotina na mesma instãncia            tt.NovaThread();        }

        // Note que NovaThread é agora um método de instãncia        void NovaThread()        {            if (!ok)             {                 ok = true;                 Console.WriteLine("www.macoratti.net");             }        }    }}

Uma outra forma de compartilhar dados entre as threads é definir campos estáticos. Veja um exemplo no código a seguir:

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;

namespace UsandoThreads_4{    class Program    {        static bool ok;

        static void Main(string[] args)        {

Executando este código o resultado será o mesmo que o exemplo anterior,

Se alterarmos a ordem das instruções na rotina NovaRotina();

static void NovaRotina(){  if (!ok)   {     Console.WriteLine("www.macoratti.net");     ok = true;   }}Poderemos obter após algumas

            new Thread(NovaRotina).Start();            NovaRotina();            Console.ReadKey();         }

        static void NovaRotina()        {            if (!ok)             {                 ok = true;                 Console.WriteLine("www.macoratti.net");             }        }

    }}

execuções o resultado a seguir:

Mas o que esta acontecendo ???

O problema é que uma thread pode estar avaliando a instrução if enquanto a outra threadpode estar executando a instrução Writeline.

Temos aqui o problema : as nossas threads não são Thread Safety. Como ????

Thread safety é um conceito existente no contexto de programas multi-threads onde um trecho de código é thread-safe se :ele funcionar corretamente durante execução simultânea por vários threads.

Se o código não for thread-safe e estiver rodando em um ambiente multi-threads os resultados obtidos podem ser inesperados ou incorretos pois uma thread pode desfazer o que a outra thread já realizou. Esse é o problema clássico da atualização do contador em uma aplicação multi-thread.

Para resolver este problema podemos usar a instrução lock() que vai bloquear os recursos até que a thread que o esta usando acabe de processá-lo.

O lock funciona assim : Quando duas threads simultâneas contêm um lock() ou bloqueio, uma thread espera, até que o bloqueio seja liberado. Neste caso, somente uma thread terá acesso ao recurso por vez e dessa forma torná-lo thread-safe.

No exemplo acima podemos usar o bloqueio ou lock da seguinte forma:

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;

namespace UsandoThreads_4{    class Program    {        static bool ok;         static readonly object bloqueador  = new object;

        static void Main(string[] args)        {            new Thread(NovaRotina).Start();            NovaRotina();            Console.ReadKey();         }

        static void NovaRotina()        {          lock(bloqueador)          {            if (!ok)             {                 Console.WriteLine("www.macoratti.net");                 ok = true;             }         }

    }}

Enquanto estiver bloqueada uma thread não consome recursos do sistema.

Você também pode esperar que uma outra thread termine a sua execução usando o método Join(). Veja o exemplo:

using System;using System.Threading;

namespace UsandoThreads_5{

A execução do código imprime 1000 vezes a frase www.macoratti.net e a seguir o texto para indicar que a thread terminou:

    class Program    {        static void Main(string[] args)        {            Thread macoratti = new Thread(Rotina);            //inicia a thread            macoratti.Start();            //aguarda o término da thread            macoratti.Join();            Console.WriteLine("\r\n\r\nA Thread macoratti terminou a sua execução!");            Console.ReadKey();        }        static void Rotina()        {            for (int i = 0; i < 1000; i++)                 Console.Write("www.macoratti.net");        }    }}

Obs: \r\n -> é igual e Environment.NewLine e causa uma avançao para outra linha.

Você pode incluir um tempo de espera quando faz a chamada do Join emmilisegundos ou como um TimeSpan que retornará true se a thread játerminou ou false se o tempo expirou.

Para incluir um tempo de espera, pausar uma thread, usamos o método Sleep();

O método Sleep() é um método estático que recebe como parâmetro um valor que define o período de espera:

Thread.Sleep (TimeSpan.FromHours (1));  // pausa por 1 horaThread.Sleep (500);                                  // pausa por 500 milliseconds

Enquanto estiver esperando, quer seja através do método Sleep ou Join , a thread fica bloqueada e não consome recursos de CPU.

Se for definido o valor zero => Thread.Sleep(0) , a thread será suspensa para permitir que outras threads que estão aguardando o processamento sejam executadas.

Para bloquear uma thread indefinidamente utilize o valor Infinite => Thread.Sleep(infinite)

A partir da versão 4.0 do .NET Framework existe o método Yield => Thread.Yield() , que faz a mesma coisa, exceto pelo fato de que são liberadas somente threads que estão rodando no mesmo processo. O sistema operacional seleciona a thread que será executada.

Tanto Sleep() como Yield()são úteis para realizar testes de desempenho e diagnósticos para desvendar características thread-safety.

Neste ponto vamos fazer um resumo do que já vimos sobre Threads:

Métodos  

  Descrição

Start Faz com que uma thread seja agendado para execução.

LockBloqueia os recursos até que a thread que o esta usando acabe de processá-lo.

JoinBloqueia o segmento de chamada até que um thread seja encerrado.

SleepBloqueia o corrente thread pelo número especificado de milissegundos

Matando uma thread

Podemos matar uma thread diretamente chamando o método Abort para encerrar thread.

A chamada do método Abort faz com que a thread atual encerre a execução lançando a exceção: ThreadAbortException.

Para saber se uma thread esta viva consultamos sua propriedade IsAlive() a qual devolve true apenas se a thread foi iniciada e ainda não esta morta.

Uma thread pode estar em um dos seguintes estados:

UnstartedA thread foi criada mas não foi iniciada

Running A thread foi iniciadaWaitSleepJoin

A thread espera por um

Suspended A thread foi suspensa

StoppedA thread parou ou foi abortada

Para encerrar esta introdução sobre threads em C# nada melhor que um exemplo funcional..

Usando Threads em aplicações Windows Forms

Vamos criar uma aplicação Windows Forms usando a linguagem C# que utiliza e gerencia threads.

Abra o Visual C# 2010 Express Edition e crie um novo projeto do tipo Windows Application com o nome DemoThreads;

- Adicione um controlo de botão ao formulário e altere sua propriedade Name para btnIniciar;- Adicione um componente de ProgressBar ao formulário e altere sua propriedade Name para : pgbThreads;

O leiaute do formulário é bem simples e esta exibido a seguir:

- Clique com o botão direito do mouse no formulário e clique em Ver código;- Defina o seguinte namespace no formulário: using System.Threading;

- Defina no evento Click do botão de comando - btnIniciar o seguinte código;

 private void btnIniciar_Click(object sender, EventArgs e) {            MessageBox.Show("Esta é a thread principal do programa"); }

- Defina também a variável trd do tipo Thread no formulário;

private Thread trd;

Após isso vamos criar uma rotina chamada ThreadTarefa que vai desenhar a barra de progresso;

Este código é um laço infinito que aleatoriamente gera incrementos para diminui o valor pbgThreds e, em seguida, aguarda 100 mili-segundos antes de continuar.

private void ThreadTarefa(){     int stp;     int novoValor;     Random rnd=new Random();

     while(true)      {    stp=this.progressBar1.Step*rnd.Next(-1,2);    novoValor = this.progressBar1.Value + stp;

    if (novoValor > this.progressBar1.Maximum)novoValor = this.progressBar1.Maximum;     else if (novoValor < this.progressBar1.Minimum)novoValor = this.progressBar1.Minimum;

     this.progressBar1.Value = novoValor;

    Thread.Sleep(100);       }}

Finalmente no evento Load do formulário vamos definir a thread e iniciá-la:

     private void Form1_Load(object sender, EventArgs e)     {            Thread trd = new Thread(new ThreadStart(this.ThreadTarefa));            trd.IsBackground = true;            trd.Start();     }

Ao executar o projeto você vai se assustar pois vai receber a seguinte mensagem de erro:

Esta exceção é lançada quando um controle em um formulário é acessado a partir de outra thread.

Mas então as threads não funcionam em projetos Windows Forms ???

Infelizmente trabalhar com threads sincronizadas para controles em aplicações Windows Forms é um problema que você terá que resolver sozinho pois não é possível trabalhar com objetos criados por outra thread a não ser usando um delegate.

A CLR - common language runtime fornece um mecanismo de callback, também chamado de delegate, o qual são equivalentes a ponteiros de funções em outras linguagens com a vantagem de possuirem um mecanismo type-safe.

Quando você declarar um delegate em seu código o compilador gera uma classe derivada da classe Delegate ou MulticastDelegate e a CLR implementa todos os métodos de interesse do delegate de forma dinâmica em tempo de execução.

Nota: A classe MulticastDelegate é uma classe abstrata que contém uma lista linkada de delegates conhecida como um lista de invocação.

Chamar um delegate é igual sintaticamente a chamar uma função, por isso, os delegates são perfeitos para implementar callbacks e eles fornecem um excelente mecanismo para desacoplar o método que

esta sendo chamado em uma instância a partir do método chamador.

Se a solução é definir um delegate vamos a ele. Veja como fica o código para este exemplo:

Obs: Esta solução foi encontrada em shabdar.org

Temos que substituir a linha de código :  

this.pgbThreads.Value = novoValor; (esta linha sai)

pela seguinte linha de código:

SetControlPropertyValue(pgbThreads,"value",novoValor); (esta linha entra)

A seguir temos que definir o delegate com o seguinte código:

       delegate void SetControlValueCallback(Control oControl, string propName, object propValue);        private void SetControlPropertyValue(Control oControl, string propName, object propValue)        {            if (oControl.InvokeRequired)            {                SetControlValueCallback d = new SetControlValueCallback(SetControlPropertyValue);                oControl.Invoke(d, new object[] { oControl, propName, propValue });            }            else            {                Type t = oControl.GetType();                PropertyInfo[] props = t.GetProperties();                foreach (PropertyInfo p in props)                {                    if (p.Name.ToUpper() == propName.ToUpper())                    {                        p.SetValue(oControl, propValue, null);                    }                }

            }        }

Para este código funcionar temos que incluir o seguinte namespace no projeto:

using System.Reflection;

Agora sim, se executarmos o projeto teremos um laço infinito onde são gerados valores aleatórios para o controle ProgressBar que é exibido no formulário;

Esta solução pode ser aplicada para qualquer controle Windows Forms e tudo o que você tem que fazer é copiar os delegate SetControlValueCallback  e a função SetControlPropertyValue e ajustar para o seu caso.

Assim se o problema estiver na utilização do controle TextBox basta fazer assim:

SetControlPropertyValue(Label1, "Text", i.ToString());

Tenha cuidado de fornecer os valores das propriedades com o tipo correto.

Quer outra solução ?

Dê uma espiada no meu artigo :

Executando procedures em Threads

Que mostra como fazer isso usando o novo controle BackgroundWorker.

Simples, simples assim...

Eu sei é apenas C# , mas eu gosto...

Pegue o projeto completo aqui: DemoThreads.zipReferências:

Trabalhando com MultiThreads no VB.NET Trabalhando com Threads Executando procedures em Threads Usando Delegates

José Carlos Macoratti

é Carlos Macoratti

C# - Validando o IBAN- International Bank Account Number

Você já ouviu falar em IBAN ?

International Bank Account Number (IBAN; número internacional de conta bancária) é um código-padrão internacional para a identificação de contas bancárias. Foi originalmente adotado pelo European Commitee for Banking Standards e posteriormente adotado como ISO 13616:1997 e atualmente ISO 13616:2007.

O IBAN é composto, no máximo, por 34 caracteres. Os dois primeiros caracteres correspondem ao país de domicilio da conta (PT-Portugal, ES-Espanha, DE-Alemanha, etc.). O terceiro e quarto caracteres são de controle e servem para validação do código do país. Os restantes dígitos correspondem à estrutura de identificação de contas definida para cada país. (fonte: http://pt.wikipedia.org/wiki/International_Bank_Account_Number)

O objetivo do IBAN é facilitar o processamento automático de pagamentos e cobranças. O padrão assegura a transmissão correta dos dados e reduz as possibilidades de intervenção manual. Portanto, contribui para evitar os custos e as demoras associadas à transmissão incorreta ou insuficiente dos dados relativos às contas bancárias.

O IBAN não é utilizado no Brasil mas sim na Europa, na zona do Euro; Para transferências para o Brasil o mais usado é o SWIFT ou Western Union.

SWIFT é uma abreviatura de Society for Worldwide Interbank Financial Telecommunication uma sociedade

cooperativa sediada em La Hulpe, Bélgica, que mantém uma rede de telecomunicações segura destinada ao Mercado Financeiro em todo o mundo.

Cada membro da rede recebe um código único, que identifica a instituição em todo o mundo. A esse código acrescenta-se o código do país da instituição (ou suas agências) e a região.   Assim, o Banco do Brasil é conhecido na rede como BRAS.  Seu código no Brasil é BRAS BR RJ

Exemplo: O código da agência do Banco do Brasil em N.York é BRAS US 33. 

Mas por que eu estou falando tudo isso ???? Qual o interesse disso ???

Nenhum, se você nunca precisou ou vai precisar validar um número IBAN, mas se você por acaso trabalhar em um projeto que necessita disso ganhou o dia pois este artigo mostra uma rotina feita em C# para validar o número IBAN.

A rotina foi adaptada de um código em C++.

Abra o Visual C# 2010 Express Edition e crie um novo  projeto do tipo Windows Application com o nome de IBAN.

Para validar o número vou usar um interface bem tosca onde no formulário form1.cs vou incluir um TextBox e um Button conforme o leiaute abaixo:

Agora inclua o seguinte código no formulário:

using System;using System.Collections.Generic;using System.Drawing;using System.Windows.Forms;

namespace IBAN{ public partial class MainForm : Form { public MainForm() { InitializeComponent(); } public bool isIBAN(string iban) { string mysIBAN = iban.Replace(" ", "");

if (mysIBAN.Length > 34 || mysIBAN.Length < 5) return false; else { string LaenderCode = mysIBAN.Substring(0, 2).ToUpper(); string Pruefsumme = mysIBAN.Substring(2, 2).ToUpper(); string BLZ_Konto = mysIBAN.Substring(4).ToUpper(); if (!IsNumeric(Pruefsumme)) return false; //Prüfsumme ist nicht numerisch

if (!ISLaendercode(LaenderCode)) return false; string Umstellung = BLZ_Konto + LaenderCode + "00"; string Modulus = IBANCleaner(Umstellung);  if (98 - Modulo(Modulus, 97) != int.Parse(Pruefsumme)) return false; //Prüfsumme ist fehlerhaft } return true; }

private bool ISLaendercode(string

code) { if (code.Length != 2) return false; else { code = code.ToUpper(); string[] Laendercodes = { "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN", "AO", "AP", "AQ", "AR", "AS", "AT", "AU", "AV", "AW", "AX", "AY", "AZ", "BA", "BB", "BC", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BK", "BL", "BM", "BN", "BO", "BP", "BQ", "BR", "BS", "BT", "BU", "BV", "BW", "BX", "BY", "BZ", "CA", "CB", "CC", "CD", "CE", "CF", "CG", "CH", "CI", "CJ", "CK", "CL", "CM", "CN", "CO", "CP", "CQ", "CR", "CS", "CT", "CU", "CV", "CW", "CX", "CY", "CZ", "DA", "DB", "DC", "DD", "DE", "DF", "DG", "DH", "DI", "DJ", "DK", "DL", "DM", "DN", "DO", "DP", "DQ", "DR", "DS", "DT", "DU", "DV", "DW", "DX", "DY", "DZ", "EA", "EB", "EC", "ED", "EE", "EF", "EG", "EH", "EI", "EJ", "EK", "EL", "EM", "EN", "EO", "EP", "EQ", "ER", "ES", "ET", "EU", "EV", "EW", "EX", "EY", "EZ", "FA", "FB", "FC", "FD", "FE", "FF", "FG", "FH", "FI", "FJ", "FK", "FL", "FM", "FN", "FO", "FP", "FQ", "FR", "FS", "FT", "FU", "FV", "FW", "FX", "FY", "FZ", "GA", "GB", "GC", "GD", "GE", "GF", "GG", "GH", "GI", "GJ", "GK", "GL", "GM", "GN", "GO", "GP", "GQ", "GR", "GS", "GT", "GU", "GV", "GW", "GX", "GY", "GZ", "HA",

"HB", "HC", "HD", "HE", "HF", "HG", "HH", "HI", "HJ", "HK", "HL", "HM", "HN", "HO", "HP", "HQ", "HR", "HS", "HT", "HU", "HV", "HW", "HX", "HY", "HZ", "IA", "IB", "IC", "ID", "IE", "IF", "IG", "IH", "II", "IJ", "IK", "IL", "IM", "IN", "IO", "IP", "IQ", "IR", "IS", "IT", "IU", "IV", "IW", "IX", "IY", "IZ", "JA", "JB", "JC", "JD", "JE", "JF", "JG", "JH", "JI", "JJ", "JK", "JL", "JM", "JN", "JO", "JP", "JQ", "JR", "JS", "JT", "JU", "JV", "JW", "JX", "JY", "JZ", "KA", "KB", "KC", "KD", "KE", "KF", "KG", "KH", "KI", "KJ", "KK", "KL", "KM", "KN", "KO", "KP", "KQ", "KR", "KS", "KT", "KU", "KV", "KW", "KX", "KY", "KZ", "LA", "LB", "LC", "LD", "LE", "LF", "LG", "LH", "LI", "LJ", "LK", "LL", "LM", "LN", "LO", "LP", "LQ", "LR", "LS", "LT", "LU", "LV", "LW", "LX", "LY", "LZ", "MA", "MB", "MC", "MD", "ME", "MF", "MG", "MH", "MI", "MJ", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", "NB", "NC", "ND", "NE", "NF", "NG", "NH", "NI", "NJ", "NK", "NL", "NM", "NN", "NO", "NP", "NQ", "NR", "NS", "NT", "NU", "NV", "NW", "NX", "NY", "NZ", "OA", "OB", "OC", "OD", "OE", "OF", "OG", "OH", "OI", "OJ", "OK", "OL", "OM", "ON", "OO", "OP", "OQ", "OR", "OS", "OT", "OU", "OV", "OW", "OX", "OY", "OZ", "PA", "PB", "PC", "PD", "PE", "PF", "PG", "PH", "PI", "PJ", "PK", "PL", "PM", "PN", "PO", "PP", "PQ", "PR", "PS", "PT", "PU", "PV", "PW", "PX", "PY", "PZ", "QA",

"QB", "QC", "QD", "QE", "QF", "QG", "QH", "QI", "QJ", "QK", "QL", "QM", "QN", "QO", "QP", "QQ", "QR", "QS", "QT", "QU", "QV", "QW", "QX", "QY", "QZ", "RA", "RB", "RC", "RD", "RE", "RF", "RG", "RH", "RI", "RJ", "RK", "RL", "RM", "RN", "RO", "RP", "RQ", "RR", "RS", "RT", "RU", "RV", "RW", "RX", "RY", "RZ", "SA", "SB", "SC", "SD", "SE", "SF", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SP", "SQ", "SR", "SS", "ST", "SU", "SV", "SW", "SX", "SY", "SZ", "TA", "TB", "TC", "TD", "TE", "TF", "TG", "TH", "TI", "TJ", "TK", "TL", "TM", "TN", "TO", "TP", "TQ", "TR", "TS", "TT", "TU", "TV", "TW", "TX", "TY", "TZ", "UA", "UB", "UC", "UD", "UE", "UF", "UG", "UH", "UI", "UJ", "UK", "UL", "UM", "UN", "UO", "UP", "UQ", "UR", "US", "UT", "UU", "UV", "UW", "UX", "UY", "UZ", "VA", "VB", "VC", "VD", "VE", "VF", "VG", "VH", "VI", "VJ", "VK", "VL", "VM", "VN", "VO", "VP", "VQ", "VR", "VS", "VT", "VU", "VV", "VW", "VX", "VY", "VZ", "WA", "WB", "WC", "WD", "WE", "WF", "WG", "WH", "WI", "WJ", "WK", "WL", "WM", "WN", "WO", "WP", "WQ", "WR", "WS", "WT", "WU", "WV", "WW", "WX", "WY", "WZ", "XA", "XB", "XC", "XD", "XE", "XF", "XG", "XH", "XI", "XJ", "XK", "XL", "XM", "XN", "XO", "XP", "XQ", "XR", "XS", "XT", "XU", "XV", "XW", "XX", "XY", "XZ", "YA", "YB", "YC", "YD", "YE", "YF", "YG", "YH", "YI",

"YJ", "YK", "YL", "YM", "YN", "YO", "YP", "YQ", "YR", "YS", "YT", "YU", "YV", "YW", "YX", "YY", "YZ", "ZA", "ZB", "ZC", "ZD", "ZE", "ZF", "ZG", "ZH", "ZI", "ZJ", "ZK", "ZL", "ZM", "ZN", "ZO", "ZP", "ZQ", "ZR", "ZS", "ZT", "ZU", "ZV", "ZW", "ZX", "ZY", "ZZ" };

if (Array.IndexOf(Laendercodes, code) == -1) return false; else return true; } }

private string IBANCleaner(string sIBAN) { for (int x = 65; x < 90; x++) { int replacewith = x - 64 + 9; string replace = ((char)x).ToString(); sIBAN = sIBAN.Replace(replace, replacewith.ToString()); } return sIBAN; }

private int Modulo(string sModulus, int iTeiler) { int iStart,iEnde,iErgebniss,iRestTmp,iBuffer; string iRest = "",sErg = "";

iStart = 0; iEnde = 0; while (iEnde <= sModulus.Length - 1) { iBuffer = int.Parse(iRest + sModulus.Substring(iStart, iEnde - iStart + 1));

if (iBuffer >= iTeiler) { iErgebniss = iBuffer / iTeiler; iRestTmp = iBuffer - iErgebniss * iTeiler; iRest = iRestTmp.ToString();

sErg = sErg + iErgebniss.ToString();

iStart = iEnde + 1; iEnde = iStart; } else { if (sErg != "") sErg = sErg + "0";

iEnde = iEnde + 1; } } if (iStart <= sModulus.Length) iRest = iRest + sModulus.Substring(iStart); return int.Parse(iRest); } private bool IsNumeric(string value) { try { int.Parse(value); return (true); } catch { return (false); } } }}

E  no evento Click do botão de comando inclua o seguinte código para testar a rotina:

void Button1Click(object sender, EventArgs e){

if (isIBAN(txtIBAN.Text)){

MessageBox.Show("IBAN "+ txtIBAN.Text + " é valido");

}else{

MessageBox.Show("IBAN "+ txtIBAN.Text + " é INvalido");

}}

Executando o projeto e realizando um teste com um número IBAN válido para Portugal temos:

Simples, simples assim...

Pegue o código completo usado no artigo aqui: IBAN.zip

Eu sei é apenas C#, mas eu gosto...

Referências:

IBAN Calculator - http://www.ibancalculator.com/ http://pt.wikipedia.org/wiki/International_Bank_Account_Number

José Carlos Macoratti

C# - Agenda de endereços

Uma agenda de endereços na linguagem C# que mostra como realizar as operações básicas de acesso e manutenção de dados em um arquivo SQL Server.

O script para gerar o banco de dados Agenda.mdf:

CREATE DATABASE [Agenda] ON PRIMARY ( NAME = N'Agenda', FILENAME = N'c:\Program Files\Microsoft SQL Server\MSSQL10.SQLEXPRESS\MSSQL\DATA\Agenda.mdf' , SIZE = 3072KB , MAXSIZE = UNLIMITED, FILEGROWTH = 1024KB )LOG ON ( NAME = N'Agenda_log', FILENAME = N'c:\Program Files\Microsoft SQL Server\MSSQL10.SQLEXPRESS\MSSQL\DATA\Agenda_log.ldf' , SIZE = 1024KB , MAXSIZE = 2048GB , FILEGROWTH = 10%)GO

O script para criar a tabela Agenda:

CREATE TABLE [dbo].[Agenda](   [id] [int] IDENTITY(1,1) NOT NULL,   [nome] [nvarchar](50) NULL,   [endereco] [nvarchar](50) NULL,   [cidade] [nvarchar](50) NULL,   [estado] [nvarchar](50) NULL,   [pais] [nvarchar](50) NULL,   [telefone] [nvarchar](50) NULL,   [email] [nvarchar](100) NULL,CONSTRAINT [PK_Agenda] PRIMARY KEY CLUSTERED ([id] ASC)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]) ON [PRIMARY]

GO

O formulário que apresenta os parâmetros para conexão com o banco de dados SQL Server:

O formulário principal onde podemos alterar, incluir e excluir informações sobre endereços:

O código é bem simples e fácil de entender para quem esta iniciando o aprendizado e precisa de um exemplo funcional de acesso a dados com C#.

Simples, simples assim...

Pegue o projeto completo aqui: AgendaCSharp.zipReferências:

Criando uma agenda de endereços Agenda com ListView e alguns

recursos Agenda completa com acesso a dados

VB .NET - Criando uma agenda VB.NET - Aplicações completas para

você aprender a programar. C# - Conexão com os principais SGBD C# - Acessando uma tabela Access C# - Sintaxe e conceitos básicos C# - Criando uma aplicação em 3

camadas C# - Usando SQLite C# - Operações básicas de acesso a

dados

José Carlos Macoratti

C# - Acessando e obtendo dados com DataReader

Este artigo mostra como acessar um banco de dados e exibir as informações das tabelas usando ADO .NET, mais especificamente a classe DataReader.

A classe DataReader fornece funções similares aos cursores SQL, os quais não são atualmente suportados na plataforma .NET. Dessa forma ela é usada para retornar um fluxo de dados e somente-para-frente e somente-leitura de uma fonte de dados de forma muito eficiente.

Os DataReaders são apropriados quando você precisa simplesmente exibir o resultado de uma consulta em cenários onde as informações não precisam ser atualizadas nem persistidas através de múltiplas requisições.

A classe DataReader é um componente ADO .NET que possui diversos componentes para acesso e manipulação de dados e que possui dois componentes principais:

DataSet - o principal componente da arquitetura desconectada ADO .NET usado para acesso independente da fonte de dados;

.NET Data Provider - inclui os objetos Connection, Command, DataReader e DataAdapter;

A seguir temos uma figura mostrando os componentes da arquitetura ADO .NET:

Neste exemplo eu vou acessar o banco de dados Northwind.mdf do banco de dados SQL Server e exibir informações em um projeto Windows Forms usando a linguagem C#.

Este é um artigo para iniciantes e aborda o acesso a dados, a utilização da classe DataReader em um projeto Windows Forms.

Para criar o projeto deste artigo eu vou usar o Visual C# 2010 Express Edition ( ele é gratuito).

Abra o Visual C# 2010 Express e crie um novo projeto do tipo Windows Forms Application com o nome acesso_DataReader;

No exemplo deste artigo vamos criar uma interface que permite que usuários efetuem consultas na tabela Products do banco de dados Northwind usando uma consulta com parâmetros e a classe DataReader.

Vamos definir a interface com o usuário no formulário form1.vb conforme o leiaute da figura abaixo:

Os componentes usados a partir da ToolBox foram:

1 TextBox - txtProduto; 1 Button - btnLocalizar; 1 listBox - lbProdutos

O projeto vai funcionar assim:

1. O usuário informa na caixa de texto o nome completo ou parcial de um produto que deseja localizar e clica no botão para localizar;

2. O código executa uma consulta SQL usando parâmetros e obtém um DataReader com as informações exibindo-as no ListBox;

A seguir temos a imagem mostrando a tela principal do programa exibindo informações dos produtos da tabela Products do banco de dados Northwind.mdf;

Observe que basta o usuário digitar um caractere para que produtos iniciados pelo caractere sejam exibidos e que também exibidos o total de produtos localizados para a consulta.

Vejamos como podemos implementar o código para realizar tal tarefa.

Iniciamos definindo os namespaces usados no projeto:

using System;using System.ComponentModel;using System.Data;using System.Windows.Forms;using System.Data.SqlClient;using System.Configuration;

Os namespaces System.Data e System.Data.SqlClient nos dão acesso as classes de acesso a dados usadas no projeto : SqlConnection, SqlCommand, SqlDataReader e a propriedade ConnectionState;

O namespace Configuration permite usarmos a classe ConfigurationManager para obter a string de conexão do arquivo App.Config que é exibido abaixo:

<?xml version="1.0" encoding="utf-8" ?><configuration> <configSections> </configSections> <connectionStrings> <add name=

"acesso_DataReader.Properties.Settings.NORTHWNDConnectionString" connectionString="Data Source=.\SQLEXPRESS;AttachDbFilename=C:\dados\NORTHWND.MDF;Integrated Security=True;Connect Timeout=30;User Instance=True" providerName="System.Data.SqlClient" /> </connectionStrings></configuration>

Além de definir o namespace devemos incluir uma referência no projeto a System.Configuration para isso clique com o botão direito do mouse sobre o nome do projeto e selecione Add Reference;

Em seguida selecione na aba .NET a opção System.Configuration e clique Ok;

Agora vamos definir as variáveis objeto usadas no projeto declarando-as logo após no início do formulário form1::

SqlDataReader rdr = null;SqlConnection con = null;SqlCommand cmd = null;

Crie a rotina getConexaoBD no formulário form1 que vai obter a string de conexão do arquivo App.Config usando a classe ConfigurationManager, criar uma nova conexão e retorna a conexão criada:

private SqlConnection getConexaoBD() {

//obtem a string de conexão do App.Config e retorna uma nova conexao string strConexao = ConfigurationManager.ConnectionStrings["acesso_DataReader.Properties.Settings.NORTHWNDConnectionString"].ConnectionString; return new SqlConnection(strConexao); }

No evento Click do botão para localizar produtos , ao lado da caixa de texto, defina o seguinte código:

private void btnLocalizar_Click(object sender, EventArgs e) { try { con = getConexaoBD(); con.Open();

// define o command com a consulta dada e associa a conexão string sql = "SELECT ProductID, ProductName, UnitPrice" + " FROM Products" + " WHERE (ProductName LIKE @nomeProduto)" + " ORDER BY ProductID";

cmd = new SqlCommand(sql); cmd.Connection = con;

// define o parâmetro cmd.Parameters.Add(new SqlParameter( "@nomeProduto", // o nome do produto System.Data.SqlDbType.NVarChar, // o tipo do parametro 20, // o tamanho do parametro "ProductName")); // o nome da coluna

// Preenche o parametro com o valor obtido do campo texto cmd.Parameters["@nomeProduto"].Value = txtProduto.Text + "%";

// Executa a cosulta rdr = cmd.ExecuteReader(); // limpa o listbox lbProdutos.Items.Clear(); //define o total de registros como zero int nuReg = 0; //percorre o leitor e exibe os valores no listbox while (rdr.Read()) { lbProdutos.Items.Add(rdr["ProductID"].ToString() + " - " + rdr["ProductName"].ToString() + " - " + rdr["UnitPrice"].ToString()); nuReg++; } //exibe o total de registros obtidos lbltotal.Text = nuReg.ToString() + " Produtos"; } catch (Exception ex)

{ // mensagem de erro MessageBox.Show(ex.Message); } finally { // fecha os objetos datareader e connection if (rdr != null) rdr.Close();

if (con.State == ConnectionState.Open) con.Close(); } }

Vamos entender o código usado:

1- Obtemos uma nova conexão usando a função getConexaoBD() e a abrimos:

   con = getConexaoBD();                con.Open();

2- Definimos uma instrução SQL para retornar o código, nome e preço do produto onde o nome do produto deverá ser igual ao nome informado pelo usuário. Aqui criarmos uma consulta parametrizada onde o parâmetro foi definido como @nomeProduto. Note o sinal @ no início do nome.

A  cláusula LIKE permite efetuar uma consulta irrestrita:

Usando a cláusula LIKE

As vezes os dados que você está desejando filtrar não têm uma ocorrência exata, ou você pretende realizar uma busca mais irrestrita. Para isso devemos usar a cláusula LIKE. Supondo que desejamos filtrar todos os alunos que tenham o nome começado pelas letrar Jos, Através da cláusula LIKE podemos inserir as letras desejadas e a SQL fará uma busca parcial pela string informada: Algo como:

SELECT nome FROM tblalunos WHERE nome LIKE "Jos%"

Isto retornará os possíveis nomes: José , Josué, Josimar, Josias, etc...

Note que usamos o sinal de porcentagem (%) que funciona como um coringa , substituindo os demais caracteres.

A seguir listamos abaixo as principais ocorrências :

Tipo de ocorrência Padrão utilizado na Consulta SQL O retorno da Pesquisa

Múltiplos caracteres b%b bb, bBb, bccccB

Caractere especial b[%]b b%b

Múltiplos caracteres ab% abcdefg, abc

                // define o command com a consulta dada e associa a conexão                string sql =   "SELECT ProductID, ProductName, UnitPrice" +                                  " FROM Products" +                                  " WHERE (ProductName LIKE @nomeProduto)" +                                  " ORDER BY ProductID";

                cmd = new SqlCommand(sql);                cmd.Connection = con;

Definimos um objeto Command para a instrução sql definida e especificamos a conexão onde o comando será usado.

3- Definimos o parâmetro a ser usado , seu nome, tipo de dados, tamanho e nome da coluna sobre o qual irá atual e incluímos na coleção Parameters:

                  // define o parâmetro                      cmd.Parameters.Add(new SqlParameter(                       "@nomeProduto",                            // o nome do produto                        System.Data.SqlDbType.NVarChar,   // o tipo de dados do parametro                       20,                                                  // o tamanho do parametro                       "ProductName"));                            // o nome da coluna

                // Preenche o parametro com o valor obtido do campo texto                cmd.Parameters["@nomeProduto"].Value = txtProduto.Text + "%"

Ao definir o valor do parâmetro obtemos o valor informado na caixa de texto txtProduto e acrescentamos o curinga '%' a final do texto digitado para ser usado com a cláusula LIKE que já explicamos acima.

4- Executamos a consulta obtendo um DataReader (rdr), e preenchemos o controle ListBox com as informações obtidas:

               // Executa a cosulta                rdr = cmd.ExecuteReader();                // limpa o listbox                lbProdutos.Items.Clear();                //define o total de registros como zero                int nuReg = 0;                //percorre o leitor e exibe os valores no listbox                while (rdr.Read())                {                    lbProdutos.Items.Add(rdr["ProductID"].ToString() +                    " - " + rdr["ProductName"].ToString() + " - " +

rdr["UnitPrice"].ToString());                    nuReg++;                }                //exibe o total de registros obtidos                lbltotal.Text = nuReg.ToString() + " Produtos";

Para obter o total de registros tivemos que usar um artifício.  Quando você usa a classe SqlDataReader ou OleDbDataReader , nao existe nenhuma propriedade RecordCount para indicar quantos registros estão sendo obtidos

O objeto DataReader ou a fonte de dados geralmente sabe quantos registros estão sendo obtidos até que o último registro seja enviado para o cliente.

Para contornar este problema, use um dos seguintes métodos:

Conte os registros enquanto você percorrer o leitor. Execute uma consulta SELECT COUNT(*) primeiro. Observe

que essa consulta pode ser desatualizada quando que terminar de ler os dados.

Dessa forma cumprimos nosso objetivo e obtemos os registros desejados usando um DataReader. Para melhorar o código sugiro que você crie uma camada e remova o código de acesso a dados do formulário usando as boas práticas.

Pegue o projeto completo aqui:   acesso_DataReader.zip

Eu sei é apenas C#, mas eu gosto...

C# , Simples, simples assim...

Referências:

C# - ADO .NET para iniciantes - DataReader

C# - Preenchendo um DataGridView SQL - Selecionando dados com SQL

Seção C# do site

José Carlos Macoratti

C# - Capturando telas

Que tal uma aplicação para capturar telas usando a linguagem C# ?

Abra o seu Visual C# 2008 Express Edition e crie um projeto do tipo Windows Forms Application no menu File -> New Project e informe o nome CapturaTela;

Obs: Podemos usar o mesmo código usando o Visual C# 2010 Express Edition

A seguir no formulário form1.cs da aplicação inclua ao seguintes controles:

3 Buttons - Name= btnCapturaTela , Name=btnSalvarTela , Name= btnLimpar e Name=btnEncerrar

1 PictureBox - Name = picTela , BorderStyle = FixedSingle , Anchor = Top, Bottom, Left, Right , SizeMode= StretchImage;

1 SaveDialog - Name = svdTela, Filter = JPEG Files|*.jpg|GIF Files|*.gif|PNG Files|*.png

1 Timer - Name=tmTela, Interval= 500

Defina no formulário form1.cs os controles conforme o leiaute da figura abaixo:

Vamos ao código da aplicação...

1- Código do evento Click do botão - Capturar Tela:

private void btnCapturarTela_Click(object sender, EventArgs e) { //oculta o formulário e inicia a captura this.Hide(); tmTela.Start(); }

Ao clicar no botão Capturar Tela a rotina oculta o formulário atual e dispara o evento do controle timer onde temos o seguinte código que irá capturar a tela:

Sem a utilização do timer não seria possível esconder o formulário atual.

private void timer1_Tick(object sender, EventArgs e) { //armazena a imagem no bitmap Bitmap b = new Bitmap(TelaLargura, TelaAltura); //copia a tela no bitmap g = Graphics.FromImage(b); g.CopyFromScreen(Point.Empty, Point.Empty, Screen.PrimaryScreen.Bounds.Size); //atribui a imagem ao picturebox exibindo-a picTela.Image = b; this.Show(); //habilita o botão para salvar a tela btnSalvarTela.Enabled = true; //encerra o timer tmTela.Stop(); }

O código do botão Salvar Tela é mostrado a seguir. Ele abre uma janela de diálogo e salva a tela capturada:

private void btnSalvarTela_Click(object sender, EventArgs e) { //abre a janela de dialogo SaveDialog para salvar o arquivo gerado na captura DialogResult res = svdTela.ShowDialog(); if (res == DialogResult.OK) { //obtem a extensão do arquivo salvo string ext = System.IO.Path.GetExtension(svdTela.FileName); if (ext == ".jpg") picTela.Image.Save(svdTela.FileName, System.Drawing.Imaging.ImageFormat.Jpeg); else if (ext == ".gif") picTela.Image.Save(svdTela.FileName, System.Drawing.Imaging.ImageFormat.Gif); else if (ext == ".png") picTela.Image.Save(svdTela.FileName,

System.Drawing.Imaging.ImageFormat.Png); } }

Para encerrar temos o código dos botões Limpar e Encerrar que limpa o controle PictureBox e encerra a aplicação:

private void btnEncerrar_Click(object sender, EventArgs e) { this.Close(); }

private void btnLimpar_Click(object sender, EventArgs e) { this.picTela.Image = null; }

Executando o projeto e capturando uma tela teremos como resultado algo parecido com a imagem abaixo: (Observe que o formulário do projeto não foi capturado)

Simples, simples assim...

Eu sei é apenas C# , mas eu gosto...

Pegue o projeto completo aqui: CapturaTela.zipReferências:

VB .NET - Capturando Telas Capturando a imagem da tela do seu computador VB.NET - Capturando imagens com Web Cam Cadastro de Cliente com WebCam Gecom - ficha técnica Windows Mobile - Manipulando Imagens

José Carlos Macoratti

C# - Exibindo informações do banco de dados com ListView e TreeView

Este artigo mostra como acessar um banco de dados e exibir as informações das tabelas usando os controles ListView e TreeView.

Neste exemplo eu vou acessar um banco de dados Microsoft Access mas o código pode ser facilmente adaptado para acessar outros bancos de dados como SQL Server, MySQL, FireBird, etc.

Este é um artigo para iniciantes e aborda o acesso a dados, a utilização dos controles ListView e TreeView, a utilização do OpenFileDialog.

Para criar o projeto deste artigo eu vou usar o Visual C# 2010 Express Edition (ele é gratuito).

Abra o Visual C# 2010 Express e crie um novo projeto do tipo Windows Forms Application com o nome acessoDados_TreeView;

Em seguida vamos definir a interface com o usuário no formulário form1.vb conforme o leiaute da figura abaixo:

Os componentes usados a partir da ToolBox foram:

2 GroupBox - 1 exibe os textbox e outro contém o container SplictContainer;

1 SplitContainer - (2 Panels }: 1- contendo o TreeView e o outro o ListView);

2 TextBox - txtBancoDados e txtTabela; 1 Button - btnSelecionaBD; 1 ImageList - contém imagens para serem exibidas no ListView

e treeView; 1 MenuStrip - menu da aplicação com opção Sair;

O projeto vai funcionar assim:

1. O usuário seleciona um banco de dados Microsoft Access clicando no botão de comando;

2. A janela OpenFileDialog será aberta exibindo os arquivos .mdb da pasta c:\dados ; (Defini esta pasta como inicial mas você pode usar outra pasta.)

3. Após selecionar um banco de dados o seu nome será exibido no TextBox - txtBancoDados e as tabelas serão exibidas no controle TreeView - tvDados;

4. Ao expandir uma tabela clicando no sinal de (+) ao lado da mesma os campos e os dados da tabela serão exibidos no controle ListView - lvDados;

A seguir temos a imagem mostrando a tela principal do programa exibindo informações para o banco de dados Northwind.mdb nos controles ListView e TreeView;

No código do projeto eu estou usando dois arrays do tipo ArrayList: tabelaArray : para salvar os nomes das tabelas e camposArray - para salvar os nomes dos campos

As rotinas definidas no código são as seguintes:

conexaoDados(string arquivoDadosBD) - usada para fazer a conexão com o banco de dados;

PreencherTreeVie()w - usada para preencher o controle TreeView com informações das tabelas do banco de dados;

GetTabelas(conexaoBD) - preenche o array tabelaArray com os nomes das tabelas;

GetCampos(conexaoBD, tabelaArray[i].ToString()) - preenche o array camposArray com os nomes dos campos da tabela;

PreencherListView(); - preenche o controle ListView com os registros da tabela selecionada;

Nas rotinas GetTabelas e GetCampos estou usando o método GetOleDbSchemaTable para obter informações do esquema do banco de dados.

Para obter o nomes dos campos estou usando OleDbSchemaGuid, e, os nomes dos campos são retornados ordenados (A-Z)

Definindo o código da aplicação

Vamos agora mostrar passo a passo o código das rotinas criadas no projeto para que a aplicação faça o que foi proposto.

-Namespaces usados no projeto:

using System;using System.Data;using System.Windows.Forms;using System.Collections;using System.Data.OleDb;

Os namespaces System.Data e System.Data.OleDb devem ser usados para termos acesso as classes ADO .NET e ao provedor OleDb para acesso ao Microsoft Access.

O namespace System.Collections é usado para ter acesso a classe ArrayList.

- Variáveis globais definidas logo após a declaração do formulário form1;

private OleDbConnection conexaoBD;private string arquivoDados;private ArrayList tabelaArray;private ArrayList camposArray;

- Código definido no evento Load do formulário form1 da aplicação responsável por inicializar os controles TreeView e ListView;

private void Form1_Load(object sender, EventArgs e) { // inicializa o TreeView

tvDados.ImageList = imageList1; // inicializa o ListView lvDados.SmallImageList = imageList1; lvDados.Clear(); lvDados.View = View.Details; lvDados.LabelEdit = false; lvDados.FullRowSelect = true; lvDados.GridLines = true; }

- Código definido no evento Click do botão para selecionar um arquivo que exibe a janela para seleção do arquivo .mdb;

private void btnSelecionaBD_Click(object sender, EventArgs e) { arquivoDados = selecionaArquivoBD("c:\\dados\\"); conexaoDados(arquivoDados); txtBancoDados.Text = arquivoDados; }Após selecionar o arquivo será aberta a conexão com o mesmo e definido o seu nome na caixa de texto.- Código da rotina conexaoDados(arquivoDados) ; private void conexaoDados(string arquivoDadosBD) { //define a string de conexão usando o provedor Oledb string conexao = @"provider=microsoft.jet.oledb.4.0;Password="""";data source=" + arquivoDadosBD; try { //Inicializa o objeto conexaoBD conexaoBD = new OleDbConnection(conexao); } catch (Exception ex) { MessageBox.Show(ex.Message); } preencherTreeView(); }neste código é chamada a rotina preencherTreeView();- Código da rotina preencherTreeView() que obtém informações sobre as tabelas e os campos exibindo-as no controle TreeView; private void preencherTreeView() { tvDados.Nodes.Clear(); // define o no raiz para o TreeView. tvDados.Nodes.Add("Database");

tvDados.Nodes[0].ImageIndex = 0; tvDados.Nodes[0].SelectedImageIndex = 0; tvDados.Nodes[0].Tag = "RootDB";

GetTabelas(conexaoBD);

// inclui um no tabela for (int i = 0; i < tabelaArray.Count; i++) { tvDados.Nodes[0].Nodes.Add(tabelaArray[i].ToString()); tvDados.Nodes[0].Nodes[i].Tag = "Tabelas"; tvDados.Nodes[0].Nodes[i].ImageIndex = 2; tvDados.Nodes[0].Nodes[i].SelectedImageIndex = 2; }

// inclui um no campo for (int i = 0; i < tabelaArray.Count; i++) { GetCampos(conexaoBD, tabelaArray[i].ToString()); for (int j = 0; j < camposArray.Count; j++) { tvDados.Nodes[0].Nodes[i].Nodes.Add(camposArray[j].ToString()); tvDados.Nodes[0].Nodes[i].Nodes[j].Tag = "Campos"; tvDados.Nodes[0].Nodes[i].Nodes[j].ImageIndex = 4; tvDados.Nodes[0].Nodes[i].Nodes[j].SelectedImageIndex = 4; } } }Este código usa as rotinas GetTabelas() e GetCampos() para obter informações das tabelas e seus campos.- Código da rotina GetTabelas() que obtém informação sobre o esquema , no caso o nome das tabelas e preenche o array tabelaArray; private void GetTabelas(OleDbConnection conBD) { try { //abre a conexão conBD.Open(); //obtem informações do esquema (nome das tabelas do banco de dados) DataTable schTable = conBD.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, new Object[] { null, null, null, "TABLE" });

tabelaArray = new ArrayList(); //preenche o array com o nome das tabelas

foreach (DataRow datRow in schTable.Rows) { tabelaArray.Add(datRow["TABLE_NAME"].ToString()); } conBD.Close(); } catch (Exception ex) { MessageBox.Show(ex.Message); } }- Código da rotina GetCampos() que obtém informações sobre os nomes dos campos da tabela e preenche o arraylist camposArray; private void GetCampos(OleDbConnection conBD, string tabNode) { string tabelaNome; try { tabelaNome = tabNode; //abre a conexão conBD.Open(); //obtem informações do esquema (nome dos campos da tabela) DataTable schTable = conBD.GetOleDbSchemaTable(OleDbSchemaGuid.Columns, new Object[] { null, null, tabelaNome });

camposArray = new ArrayList(); //preenche o array com o nome dos campos foreach (DataRow datRow in schTable.Rows) { camposArray.Add(datRow["COLUMN_NAME"].ToString()); } conBD.Close(); } catch (Exception ex) { MessageBox.Show(ex.Message); } }- Código do evento AfterExpand do controle TreeView que é disparado quando o usuário expande um nó Tabela exibindo os dados no ListView; private void tvDados_AfterExpand(object sender, TreeViewEventArgs e) { string tabelaNome; int contadorCampo;

if (e.Node.Tag.ToString() == "RootDB") { e.Node.ImageIndex = 1; e.Node.SelectedImageIndex = 1; } else if (e.Node.Tag.ToString() == "Tabelas") { e.Node.ImageIndex = 3; e.Node.SelectedImageIndex = 3; contadorCampo = e.Node.GetNodeCount(false); // cria o cabeçalho das colunas. int n = lvDados.Width; double largura = n / contadorCampo ; // largura a coluna for (int c = 0; c < contadorCampo; c++) { lvDados.Columns.Add(e.Node.Nodes[c].Text, (int)largura, HorizontalAlignment.Left); } // pega o nome da tabela tabelaNome = e.Node.Text; PreencherListView(conexaoBD, tabelaNome); } }Neste evento é chamada a rotina PreencherListView().- Código da rotina PreencherListView() que exibe as informações da tabela no controle ListView; private void PreencherListView(OleDbConnection conBD, string nomeTabela) { OleDbCommand cmdBD; OleDbDataReader datReader;

string strCampo; //define o nome da tabela txtTabela.Text = nomeTabela; //define uma instrução SQL para obter os dados da tabela strCampo = "SELECT * FROM [" + nomeTabela + "]"; // Inicializa o objeto command cmdBD = new OleDbCommand(strCampo, conBD); //abre a conexão e executa o command conBD.Open(); datReader = cmdBD.ExecuteReader();

// Preenche o ListView while (datReader.Read()) {

ListViewItem objListItem = new ListViewItem(datReader.GetValue(0).ToString()); for (int c = 1; c < datReader.FieldCount; c++) { objListItem.SubItems.Add(datReader.GetValue(c).ToString()); } objListItem.ImageIndex = 5; lvDados.Items.Add(objListItem); } //fecha o datareader e a conexao datReader.Close(); conBD.Close(); }O código do evento AfterCollapse do TreeView que ocorre antes do Nó é recolhido. private void tvDados_AfterCollapse(object sender, TreeViewEventArgs e) { if (e.Node.Tag.ToString() == "RootDB") { e.Node.ImageIndex = 0; e.Node.SelectedImageIndex = 0; } else if (e.Node.Tag.ToString() == "Tabelas") { e.Node.ImageIndex = 2; e.Node.SelectedImageIndex = 2; lvDados.Clear(); } }O código do evento BeferoExpand do TreeView que ocorre antes que um Nó é expandido; private void tvDados_BeforeExpand(object sender, TreeViewCancelEventArgs e) { lvDados.Clear(); // expande somente um no for (int i = 0; i < tvDados.Nodes[0].GetNodeCount(false); i++) { tvDados.Nodes[0].Nodes[i].Collapse(); } } Finalmente o código do evento Click do item do menu Sair que pergunta ao usuário se ele deseja encerrar: private void SairMenuItem_Click(object sender, EventArgs e) { if (MessageBox.Show("Deseja encerrar o programa ?", "Aplicação",MessageBoxButtons.YesNo, MessageBoxIcon.Question)

== DialogResult.Yes) { Application.Exit(); } }Eu sei é apenas C# mas eu gosto...Pegue o projeto completo aqui: acessoDados_TreeView.zipC# , Simples, simples assim... Referências:

VB .NET - Usando o controle TreeView VB. NET - Herança - criando controles herdados Usando TreeView na Pratica II VB - Exibindo tabelas e registros em um controle TreeView VB.NET   - Usando o controle TreeView III

José Carlos Macoratti

C# -  Enviando Emails

Este singelo programa feito na linguagem C# permite enviar emails usando alguns dos clientes de emails mais usados.

Fazendo um teste e enviando do meu E-mail do Yahoo, com um anexo,  para o meu outro E-mail do IG, abaixo temos a prova dos

nove: funcionou !!!

O programa usa o servidor SMTP , efetua a autenticação e permite também enviar anexos. Uma beleza...

Se você espiar o código vai se espantar pela simplicidade.

Você pode então usar todo o seu conhecimento para incrementar

ainda mais o programa ou usá-lo como esta...

Simples, simples assim...

Pegue o programa completo aqui: EmailClient.zipReferências:

Enviando emails com ASP.NET : HTML e anexos Emails , emails , emails... Enviando emails com ASP.NET Enviando Emails ASP.NET 2.0 - Enviando Emails Envi ando um E-mail com ASP Enviando E-mails com o Visual Basic ...

José Carlos Macoratti

C# - Conceitos - Apresentando Arrays

Já falei sobre arrays mas relacionados com a linguagem VB .NET. O conceito em si é o mesmo mas a sintaxe em C# é diferente por isso vou começar do início para apresentar os Arrays e como usá-los na linguagem C#.

Vou começar com a definição de array da wikipédia (http://pt.wikipedia.org/wiki/Array) resumida:

Um Array é um conjunto de elementos de um mesmo tipo de dados onde cada elemento do conjunto é acessado pela posição no array que é dada através de um índice (uma sequência de números inteiros).  Um array de uma dimensão é também conhecido como vetor,e , um array de mais de uma dimensão e conhecido como uma matriz. Agora uma definição mais geral:

Um array é uma estrutura de dados que contém uma série de dados ordenados, chamados "elementos". Os elementos são referenciados por número ordinal (índice), primeiro elemento é 1, segundo 2, etc. Os elementos podem ser de qualquer tipo, string, caractere, numérico, data, etc.

Se você não fugiu da escola vai lembrar do conceito de Matriz em matemática. Lembra ??? É a mesma coisa...

Uma matriz real (ou complexa) é uma função que a cada

par ordenado (i,j) no conjunto Smn associa um número real (ou complexo).Uma forma comum e prática para representar uma matriz definida na forma acima é através de uma tabela

contendo m×n números reais (ou complexos).

Fonte : http://twixar.com/6v9

Declarando Arrays em C#

Na linguagem C#  os arrays possuem o índice com base zero, ou seja, o primeiro elemento do array possui o índice zero (0).

Um array de uma dimensão é declarado informando o tipo de dados do array seguido do nome do array, lembrando que devemos colocar colchetes ([]) depois do tipo do array e não após o seu nome:

Ex:  int[] tabela; ==> correto     int tabela[];  ==> incorreto

Na linguagem C# o tamanho do arrray não é parte do seu tipo, isso permite declarar uma array e em seguida atribuir qualquer array de objetos int a ele, sem considerar o seu tamanho:

Ex:    int[] numeros;                          //declara numeros como um array de inteiros de qualquer tamanho         numeros = new int[10];          // numeros agora é um array de 10 elementos         numeros = new int[20];          // numeros agora é um array de 20 elementos

Além de arrays de uma dimensão a linguagem C# suporta os seguintes tipos de arrays:

- Arrays com mais de uma dimensão :

    string[,] names;          int[,] array = new int[2, 2];

-  Array-of-arrays (jagged):

     byte[][] resultados;     int[][] numArray = new int[][] { new int[] {1,3,5}, new int[] {2,4,6,8,10} };

Criando e inicializando um Array

Em C# declaramos um array assim :

string[] nomes;    //array nomes de qualquer tamanho

mas isso não cria o array para fazer isso devemos declarar:

nomes = new string[5];        //array de strings de 5 elementos 

finalmente para incializar o array fazemos assim:

nomes[0] = "José";nomes[1] = "Carlos";nomes[2] = "Macoratti";nomes[3] = "Miriam";nomes[4] = "Estela";

Observe o índice indicando a posição do elemento no array. O primeiro elemento é o zero e o último é 4. Assim temos 5 elementos no array com posições : 0,1,2,3 e 4.

Para um array de mais de uma dimensão a sintaxe usada pode ser:

string[,] names = new string[5,4];   //declara um array bidimensional com 5 linhas e 4 colunas

Existem outras formas de iniciar um array:

1- Uma Dimensão

 definindo o tamanho e o

int[] numeros = new int[5] {1, 2, 3, 4, 5};

string[] nomes = new string[3] {"Mac", "Jessica", "MiMi"}; 

operador new

int[] numeros = new int[] {1, 2, 3, 4, 5};

string[] nomes = new string[] {Mac", "Jessica", "MiMi"}; 

 omitindo o tamanho do array

int[] numeros = {1, 2, 3, 4, 5};

string[] nomes = {"Mac", "Jessica", "MiMi"}; 

 Omitindo o operador new

2- Mais de uma Dimensão

int[,] numeros = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} };

string[,] amigos = new string[2, 2] { {"Mac","Jan"}, {"Mimi","Jeff"} }; 

 definindo o tamanho e o operador new

int[,] numeros = new int[, ] { {1, 2}, {3, 4}, {5, 6} };

string[,] amigos = new string[, ] { {"Mac","Jan"}, {"Mimi","Jeff"} }; 

 omitindo o tamanho do array

int[,] numeros = { {1, 2},  Omitindo o operador new

{3, 4}, {5, 6} };

string[,] amigos = { {"Mac","Jan"}, {"Mimi","Jeff"} }; 

3- Arrays de Arrays (jagged arrays)

int[][] numeros = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} }; 

 definindo o tamanho e o operador new

 

int[][] numeros = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };                                                   ouint[][] numeros = { new int[] {2,3,4}, new int[] {5,6,7,8,9} }; 

 omitindo o tamanho do array

 

Acessando e percorrendo Arrays

Como você já sabe os elementos contidos nos arrays são identificados por um índice e é por este número que acessamos um determinado elemento no array.

Eu vou usar o Visual C# 2008 Express Edition nos exemplos deste artigo.

No exemplo a seguir eu estou declarando um array unidimensional chamado numeros do tipo int e criando e inicializando o array com 5 elementos :

private void Form1_Load(object sender, EventArgs e){   int[] numeros = { 10, 9, 8, 7, 6 };   listBox1.Items.Add("Primeiro elemento: " + numeros[0]);   listBox1.Items.Add("Segundo elemento: " + numeros[1]);   listBox1.Items.Add("Terceiro elemento: " + numeros[2]);   listBox1.Items.Add("Quarto elemento: " + numeros[3]);   listBox1.Items.Add("Quinto elemento: " + numeros[4]);}

Note que para acessar um elemento eu utilizei o seu índice, e como em C# os arrays são base zero, o primeiro elemento tem o índice igual a zero (0).

Então para acessar um elemento em um array unidimensional eu uso a sintaxe:  nome_do_array[numero_do_indice]

Para um array de mais de uma dimensão somente temos que definir os demais índices do array. No exemplo a seguir eu declaro um array bidimensional chamado numeros2 e a seguir crio e inicio o array com 5 elementos:

int[,] numeros2 = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 }, { 9, 10 } }; listBox2.Items.Add("numeros2[0,0] = " + numeros2[0, 0]); listBox2.Items.Add("numeros2[0,1] = " + numeros2[0, 1]);

listBox2.Items.Add("numeros2[1,0] = " + numeros2[1, 0]); listBox2.Items.Add("numeros2[1,1] = " + numeros2[1, 1]); listBox2.Items.Add("numeros2[2,0] = " + numeros2[2, 0]); listBox2.Items.Add("numeros2[2,1] = " + numeros2[2, 1]); listBox2.Items.Add("numeros2[3,0] = " + numeros2[3, 0]); listBox2.Items.Add("numeros2[3,1] = " + numeros2[3, 1]); listBox2.Items.Add("numeros2[4,0] = " + numeros2[4, 0]);

listBox2.Items.Add("numeros2[4,1] = " + numeros2[4, 1]);

Observe que para acessar os elementos do array eu tive que usar os dois índices que indicam a posição do elemento no array.

Para você visualizar e entender melhor o conceito veja abaixo uma ilustração do array definido acima e a sua matriz correspondente:

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

   numeros2[0, 0] = 1   numeros2[0, 1] = 2   numeros2[1, 0] = 3   numeros2[1, 1] = 4   numeros2[2, 0] = 5   numeros2[2, 1] = 6   numeros2[3, 0] = 7   numeros2[3, 1] = 8   numeros2[4, 0] = 9  

Matriz  2 x 5

numeros2[4, 1] = 10

Para atribuir valores a uma posição do array eu também uso os índices. Assim temos:

 int[,] matriz3x3 = { { 1, 0,0 }, { 0,1,0 }, { 0,0,1 } };  

Outro exemplo de array bidimensional:

string[,] livros  = {                            {"Macbeth", "Shakespear", "ID12341"},                            {"1984", "George Owell", "ID234234"},                            {"ASP - Internet ", "Macoratti", "ID3422134"}                        }; 

 Este array contém 3 linhas e 3 colunas. Para cada livro temos uma  linha e cada livro contém 3 colunas : titulo, autor e ID do livro.

numeros[4] = 100         //atribuindo o valor ao quarto elemento do array

numeros [1,1] = 200    //atribuindo o valor 200 ao elemento de posição [1,1] do array

Percorrendo Arrays

Deu para perceber que acessar e percorrer arrays com muitos elementos pode dar um trabalho danado. É para isso que servem os laços (loops), para percorrer arrays sem fazer esforço. Vejamos alguns dos principais laços usados:

O laço for é usado para ser executado um determinado número de vezes usando uma variável com um valor determinado e incrementando esta variável até o valor determinado. No exemplo abaixo a variável i recebe o valor inicial zero e a incrementa (I++) até que o seu valor seja menor que 10.

for (int i = 0; i < 10; i++){ // codigo a ser executado}

Assim podemos usar um laço for para percorrer um array existente ou atribuir valores a um array que foi declarado.

a) Exemplo:  Percorrer o array  numeros declarado a seguir e exibir os seus valores em um controle ListBox:

    int[] numeros = { 10, 9, 8, 7, 6, 5 };

    listBox1.Items.Clear();

   for (int i = 0; i < 6 ; i++)   {      listBox1.Items.Add("Elemento [" + i +"] = " + numeros[i]);   }

O laço for usado inicia a partir do índice zero;

Percorre o array até que o valor de i seja menor que 6 , pois o array possui seis elementos mas começamos contar a partir de zero:  (0,1,2,3,4,5)

numeros[i] representa o array e i o índice atribuído a cada elemento

O resultado exibido no formulário Windows Forms será:

b) Exemplo:  Atribuir valores o array  inteiros declarado a seguir e exibir os valores em um controle ListBox.

int[] inteiros = new int[10];

int[] inteiros = new int[10];

listBox1.Items.Clear();listBox1.Items.Add("Array inteiros => int[] inteiros =

A atribuição esta sendo feita na declaração:  inteiros[i] = i;O resultado obtido é visto na figura abaixo:

new int[10]");

for (int i = 0; i < 10; i++){   inteiros[i] = i;   listBox1.Items.Add("Elemento [" + i + "] = " + i );}

Podemos usar laços while e do-while para fazer a mesma operação lembrando que esses laços são executados enquanto certa condição esta sendo atendida.

Exemplo: Estrutura do laço while e do-while;

while (i < 10) { }----------------------------------------------------------- do { } while (i < 10);

A principal diferença entre o laço while e do-while é que no laço while , a expressão é verificada antes do início da execução do laço e se o resultado for falso o laço nunca será executado. No laço do-while a verificação é feita após a primeira execução.

O laço Foreach

O laço foreach pode ser usado para acessar cada elemento do vetor ou coleção.  A sintaxe usada é : 

foreach (<tipo> <variavel> in <coleção>)

Exemplo com vetor unidimensional:

     int[] numeros = new int[5];

        numeros [0] = 10;        numeros [1] = 4;        numeros [2] = 32;        numeros [3] = 1;        numeros [4] = 20;

        foreach (int i in numeros )        {            listBox1.Items.Add("i = " + i);        }

Exemplo com vetor bidimensional:

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

 foreach (int i in numeros2 ) {       listBox1.Items.Add("i = " + i); }

Exemplo com laço foreach usando strings:

  string[] semana = new string[7];   semana[0] = "Domingo";  semana[1] =

"Segunda-feira";  semana[2] = "Ter‡a-feira";  semana[3] = "Quarta-feira";  semana[4] = "Quinta-feira";  semana[5] = "Sexta-feira";  semana[6] = "Sabado";

 foreach (string dia in semana) {       listBox1.items.Add(dia); }

Usando os métodos e propriedades do objeto Array

Em C# arrays são objetos. A classe System.Array é a classe abstrata que é a base para todos os tipos de arrays.

Observação importante:No .NET Framework versão 2.0, o Classe de Array implementa o System.Collections.Generic.IList<T>System.Collections.Generic.ICollection<T>e System.Collections.Generic.IEnumerable<T> genérico interfaces.As implementações são fornecidos para matrizes em tempo de execução, e portanto não são visíveis para as ferramentas de documentação.Como resultado, as interfaces Genéricas não aparecem na sintaxe de declaração para a classe Array, e não há nenhum tópico de referência para membros de interface que são acessíveis somente por converter uma matriz para o tipo de interface Genérica (implementações de interface explícita).

A classe Array fornece propriedades e métodos para criar, manipular, procurar e ordenar arrays. Abaixo temos os mais importantes:

1- Propriedades

IsFixedSize Retorna um valor indicando se um array possui um tamanho fixo ou não.

IsReadOnly Retorna um a valor indicando se um array é somente-leitura ou não.

IsSynchronized

Retorna um a valor que indica se o acesso a um array é thread-safe ou não.

Length Retorna o número total de itens em todas as dimensões de um array

Rank Retorna o número de dimensões de um array

SyncRoot Retorna um objeto que pode ser usado para sincronizar o acesso a um array.

2- Métodos

BinarySearch

 Procura em um array unidimensional ordenado por um valor usando o algoritmo de busca binário.

Clear  Remove todos os itens de um array e define um intervalo de itens no array com valor zero.

Clone  Cria uma cópia do Array.

Copy  Copia uma seção de um array para outro array e realiza a conversão de tipos e boxing requeridas.

CopyTo  Copia todos os elementos do array unidimensional atual para o array unidimensional especificado iniciando no índice de destino especificado do array.

CreateInstance

 Inicializa uma nova instância da classe Array.

GetEnumerator

 Retorna um IEnumerator para o Array.

GetLength  Retorna o número de itens de um Array.

GetLowerBound

 Retorna o primeiro item de um Array.

GetUpperBound

 Retorna o último item de um Array.

GetValue  Retorna o valor do item especificado no  Array.

IndexOf  Retorna o índice da primeira ocorrência de um valor em um array de uma dimensão ou em uma porção do Array.

LastIndexOf  Retorna o índice da última ocorrência de um valor em um array unidimensional ou em uma  porção do Array.

Reverse  Reverte a ordem de um item em um array de uma dimensão ou parte do array.

SetValue  Define o item especificado em um array atual para o valor definido.

Sort  Ordena os itens de um array.

A seguir temos alguns exemplos de utilização das propriedades e métodos:

Array usado nos exemplos:

string[] Cores = { "vermelho", "verde", "amarelo", "laranja", "azul" };

Obter o tamanho do Array   Cores.Length);

 

Ordenar o Array   Array.Sort(Cores) 

Inverter a ordem dos itens no Array

  Array.Reverse(Cores) 

Usar GetLowerBound/GetUpperBound

 for( int j = Cores.GetLowerBound(0); j <= Cores.GetUpperBound(0); j++) {        listBox2.Items.Add("Cores[0] = " + j + " " + Cores[j]); }

 

Verificando se o Array tem tamanho fixo

 if (Cores.IsFixedSize) {   listBox2.Items.Add("O array e fixo");   listBox2.Items.Add(" tamanho => (Cores.Lenght) = " + Cores.Length);   listBox2.Items.Add(" intervalo => (Cores.Rank) = " + Cores.Rank); }

Realizando uma busca binária no Array

 

 object oCor = "verde";  int retorno = Array.BinarySearch(Cores, oCor); if(retorno >=0)     listBox2.Items.Add("Indice do Item " + retorno.ToString()); else     listBox2.Items.Add("Item nÆo localizado");

Obtendo o índice de um item do Array  int ind =

Array.IndexOf(Cores, "verde"); listBox2.Items.Add("O índice do item 'verde' e " +

ind); 

E com isso creio que dei uma visão geral sobre os Arrays na linguagem C#. Consulte a documentação para mais exemplos e mais detalhes.

Pegue o projeto com os exemplos do artigo aqui: C_Arrays.zip

Eu sei é apenas C# mas  eu gosto.

Referências:

VB.NET - Arrays Trabalhando com Arrays VB.NET - Usando Coleções http://www.functionx.com/csharp/Lesson24.htm System.Array -

http://msdn.microsoft.com/en-us/library/system.array.aspx Array tutorial -

http://msdn.microsoft.com/en-us/library/aa288453(VS.71).aspx

José Carlos Macoratti

C# - Gerando um Documento Excel a partir de um DataTable

Vejamos o seguinte cenário clássico :

Você precisa gerar documentos no formato Excel a partir das tabelas do seu banco de dados.

É uma tarefa elementar e eu já tratei deste assunto em diversos artigos mas como saber não ocupa espaço vamos a mais uma maneira de resolver o problema.

Neste artigo eu mostro como gerar documentos Excel a partir de um DataTable de um banco de dados Excel usando a linguagem C#.

Eu poderia criar uma aplicação Windows Forms ou WPF mas vou criar uma aplicação Web usando o Visual Web Developer(VWD) 2008 Express.

Abra o VWD 2008 Express e no menu File selecione New Web Site e selecione o template ASP .NET Web Site informando o nome ExportaDados e selecionando a linguagem C#;

A seguir selecione o arquivo Default.aspx e no modo Design inclua uma tabela com 6 linhas e 2 colunas e defina o leiaute da figura abaixo no web form;

Neste formulário o usuário informa o local do banco de dados , no servidor, o nome do banco de dados e o comando SQL que será executado para gerar o DataTable.

protected void btnGeraDocumento_Click(object sender, EventArgs e) { //Conteúdo do Response Response.AddHeader("content-disposition", "attachment; filename=DocumentoExcel.xls"); Response.Charset = ""; Response.ContentType = "application/vnd.xls";

//Objetos StringWriter stringWrite = new System.IO.StringWriter(); HtmlTextWriter htmlWrite = new HtmlTextWriter(stringWrite);

//Inclui controles DataGrid dgDados = new DataGrid(); this.form1.Controls.Add( dgDados);

//Definição de cores //dgRecord.HeaderStyle.BackColor = System.Drawing.Color.Yellow; dgDados.DataSource = pegaTabela(); dgDados.DataBind();

//definição das cores das células //foreach (DataGridItem dgi in dgRecord.Items) // foreach (TableCell tcGridCells in dgi.Cells) // tcGridCells.Attributes.Add("class", "sborder");

//Renderiza o DataGrid dgDados.RenderControl(htmlWrite);

//Inluir a classe de estilo //Response.Write(@"<style> .sborder { color : Red;border : 1px Solid Balck; } </style> "); //Exporta Response.Write(stringWrite.ToString()); //encerra Response.End(); }

A rotina pegaTabela acessa o banco de dados usando o provedor OLEDB e obtém os dados da tabela retornando um DataTable;

protected DataTable pegaTabela() { string conString = @"Provider=Microsoft.JET.OLEDB.4.0;data source=" + txtLocalBD.Text + txtNomeBD.Text; // cria e abre uma conexão OleDbConnection conn = new OleDbConnection(conString); conn.Open(); DataTable dt = new DataTable(); // cria um adapter e preenche o datatable OleDbDataAdapter adapter = new OleDbDataAdapter(txtComandoSQL.Text, conn); adapter.Fill(dt); // fecha a conexão conn.Close();

return dt; }

Se você desejar criar o seu próprio DataTable e preencher com dados pode usar a rotina abaixo:

protected DataTable criaTabela() { //Cria um datatable temporario para vincular valores DataTable dtTemp = new DataTable(); DataRow dr; //cria o schema dtTemp.Columns.Add("Codigo"); dtTemp.Columns.Add("Nome"); //Imclui dados dr = dtTemp.NewRow(); dr["Codigo"] = "1"; dr["Nome"] = "Macoratti"; dtTemp.Rows.Add(dr);

dr = dtTemp.NewRow(); dr["Codigo"] = "2"; dr["Nome"] = "Miriam"; dtTemp.Rows.Add(dr); dr = dtTemp.NewRow(); dr["Codigo"] = "3"; dr["Nome"] = "Jessica"; dtTemp.Rows.Add(dr); dr = dtTemp.NewRow(); dr["Codigo"] = "4"; dr["Nome"] = "Jefferson"; dtTemp.Rows.Add(dr); dr = dtTemp.NewRow(); dr["Codigo"] = "5"; dr["Nome"] = "Janice"; dtTemp.Rows.Add(dr); //retorna o datatable return dtTemp; }

Executando o projeto , ao clicar no botão para gerar o documento veremos a janela de diálogo para abrir o documento ou salvar.

Abrindo o documento no OpenOffice (eu criei o projeto em uma máquina que não tinha o Excel) veremos a tabela exibida conforme abaixo:

Pegue o projeto completo aqui: ExportaDados.zip

Aguarde mais artigos sobre C#.

Eu sei é apenas C# mas eu gosto...

Referências:

ASP.NET - Lendo planilhas do Excel Exportando o conteúdo de um

GridView para o Excel ASP - Gerando planilha Excel Excel e VB - Importando e Exportando

dados Gerando gráficos no Excel Exportar para o Excel

José Carlos Macoratti

.NET - Acesso a banco de dados C# e Java (JLCA)

Neste artigo eu vou mostrar que de certa forma o acesso a um banco de dados feito na linguagem C# é muito parecido com o que é feito na linguagem Java.

Não espere por benchmarks comparando as duas linguagens nem espere que eu tome o partido de uma e venha a denegrir a outra, para mim linguagens de programação são ferramentas para se realizar um serviço, basta usar a ferramenta certa para o serviço certo; não existe ferramenta melhor ou pior.

Mas voltando ao nosso assunto, C# e Java usam meios similares para acessar um banco de dados:

Ambas precisam de um driver de banco de dados para realizar as operações com o banco de dados;

Ambas precisam de uma conexão com o banco de dados; Ambas precisam executar consultas SQL contra uma

conexão; Ambas precisam retornar o resultado;

Os drivers de banco de dados como JDBC ou ODBC podem ser usados para acessar dados em Java e C#.

O driver Java DataBase Connectivity (JDBC) é usado em programas escritos na linguagem Java.

O driver ODBC Open DataBase Connectivity (ODBC) é uma interface de programação da Microsoft para acessar uma variedade de banco de dados relacionais.

Em Java , a informação da string de conexão para o driver para o tratamento de uma conexão é dado como a seguir:

final static private String url = "jdbc:oracle:server,usário,senha, …)";Com C# , usando o .NET Framework, você não tem que carregar drivers ODBC ou JDBC para acessar um banco de dados.Simplesmente defina a string de conexão para o objeto Connection do banco de dados conforme a seguir:

static string connectionString = "Initial Catalog=northwind;Data Source=(local);Integrated Security=SSPI;";static SqlConnection cn = new SqlConnection(connectionString);

Em Java , para realizar uma operação de leitura em um banco de dados, você pode usar o objeto ResultSet criado pelo método executeQuery do objeto Statement. O objeto ResulstSet contém os dados retornados pela consulta.

Você pode interagir através do objeto ResultSet para acessar os dados. Veja a seguir um exemplo de código que realiza o acesso a dados usando a linguagem Java via JDBC:

try{ Class.forName (_driver); c = DriverManager.getConnection(url, usuario, senha);} catch (Exception e) { // tratamento de exceção}try{ Statement stmt = c.createStatement(); ResultSet results = stmt.executeQuery("SELECT * FROM tabela "); while(results.next()) { String s = results.getString("nomeColuna"); // Exibe cada valor da coluna no ResultSet: } stmt.close();} catch(java.sql.SQLException e){ //trata exceção para executeQuery e getString: }

Vejamos agora a mesma tarefa em C#...

Usando a linguagem C# para acessar um banco de dados você vai precisar de:

Uma conexão com o banco de dados; A definição e execução de um comando com uma instrução

SQL; Um DataAdapter que compreenda um banco de dados SQL; Uma tabela para tratar o resultado;

A seguir temos o código para acessar um banco de dados com a linguagem C#;namespace DataAccess{using System.Data;using System.Data.SqlClient;

class DataAccess{ //Esta é sua conexão com o banco de dados Northwind static string connectionString = "Initial Catalog=northwind;Data Source=(local);Integrated Security=SSPI;"; static SqlConnection cn = new SqlConnection(connectionString);

// Este é o seu objeto command que executa uma instrução SQL contra a conexão static string sCommand = "SELECT * from Products";

//Este é o seu data adapter que entende banco de dados SQL static SqlDataAdapter da = new SqlDataAdapter(sCommand, cn);

// Esta é a tabela que vai receber o resultado static DataTable dataTable = new DataTable();

static void Main(){ try{ cn.Open();

// preenche o datatabel com o resultado da consulta SQL int recordsAffected = da.Fill(dataTable);

if (recordsAffected > 0) { //percorre a tabela e exibe o primeiro campo foreach (DataRow dr in dataTable.Rows) { System.Console.WriteLine(dr[0]); } }}catch (SqlException e) { string msg = ""; for (int i=0; i < e.Errors.Count; i++) { msg += "Error #" + i + " Message: " + e.Errors[i].Message + "\n"; } System.Console.WriteLine(msg);}finally{ if (cn.State != ConnectionState.Closed) { cn.Close(); } }}}}

A sintaxe é muito parecida e os conceitos envolvidos também. Pensando nisso a Microsoft disponibilizou a ferramenta JLCA - Java Language Conversion Assistant , uma ferramenta que fornece a habilidade de converter o código Java e as chamadas para a linguagem Microsoft Visual C#.

Se você estiver interessado pegue o JLCA neste link:  Java Language Conversion Assistant 2.0

Eu sei é apenas C#, mas eu gosto...

Referências:

Visual Studio .NET - Usando C# . Por que não ? C# - Acessando uma tabela Access C# - Operações básicas de acesso a dados VB.NET e C-Sharp - Comparando C# - ADO .NET para iniciantes http://msdn.microsoft.com/en-us/aa336522.aspx

José Carlos Macoratti

C# - Vinculando uma fonte de dados XML a um controle TreeView

Imagine o seguinte cenário:

Você trabalha em uma grande empresa que recebe dados das filiais para serem consolidados. Os dados sempre estiveram em arquivos texto que você tratava e consolidava.

A partir do mês que vem os dados passarão a vir no formato XML e você terá que acessar e exibir estas informações.

Você receberá dois arquivos : um arquivo XML contendo os dados propriamente ditos e um arquivo XSD usado para validar o arquivo XML.

Não devemos confundir métodos para validar um documento XML com esquemas usados para esta finalidade. Atualmente existem três tipos de schemas usados para validar XML: DTD (Document Type Definition), XDR SchemasXSD Schemas (XML-Schema Definition)

DTD – Método inicial de validação de XML descrito no W3C XML (www.w3.org/). A recomendação atual concedida ao XSD tornou os DTD obsoletos.

XDR – Tecnologia criada pela Microsoft. similar ao XSD. Tem a vantagem de ter sido escrito usando XML. XSD – É e recomendação atual do W3C. Substitui os DTDs e os XRDs da Microsoft.

O arquivo XML chamado de estoque.xml possui a seguinte estrutura:

<?xml version="1.0" standalone="yes"?><NewDataSet><Produtos><ProdutoID>355</ProdutoID><CategoriaID>16</CategoriaID><NumeroModelo>RU007</NumeroModelo>

<NomeModelo>Rain Racer 2000</NomeModelo><ImagemProduto>image.gif</ImagemProduto><CustoUnitario>1499.99</CustoUnitario><Descricao>Looks like an ordinary bumbershoot, but don't be fooled! Simply place Rain Racer's tip on the ground and press the release latch.</Descricao></Produtos>.................<Produtos></Produtos><Categorias><CategoriaID>14</CategoriaID><NomeCategoria>Communications</NomeCategoria></Categorias>.......................<Categorias><CategoriaID>20</CategoriaID><NomeCategoria>General</NomeCategoria></Categorias></NewDataSet>

Este arquivo contém informações sobre produtos e categorias e o arquivo estoque.xsd que irá validar este arquivo e definir a sua estrutura e o relacionamento entre as tabelas possui o seguinte conteúdo:

<?xml version="1.0" standalone="yes"?><xs:schema id="NewDataSet" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> <xs:element name="NewDataSet" msdata:IsDataSet="true"> <xs:complexType> <xs:choice maxOccurs="unbounded"> <xs:element name="Produtos"> <xs:complexType> <xs:sequence> <xs:element name="ProdutoID" msdata:ReadOnly="true" msdata:AutoIncrement="true" type="xs:int" /> <xs:element name="CategoriaID" type="xs:int" /> <xs:element name="NumeroModelo" minOccurs="0"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:maxLength value="50" /> </xs:restriction> </xs:simpleType> </xs:element> <xs:element name="NomeModelo" minOccurs="0"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:maxLength value="50" /> </xs:restriction> </xs:simpleType> </xs:element> <xs:element name="ImagemProduto" minOccurs="0"> <xs:simpleType>

<xs:restriction base="xs:string"> <xs:maxLength value="50" /> </xs:restriction> </xs:simpleType> </xs:element> <xs:element name="CustoUnitario" type="xs:decimal" /> <xs:element name="Descricao" minOccurs="0"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:maxLength value="3800" /> </xs:restriction> </xs:simpleType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> <xs:element name="Categorias"> <xs:complexType> <xs:sequence> <xs:element name="CategoriaID" msdata:ReadOnly="true" msdata:AutoIncrement="true" type="xs:int" /> <xs:element name="NomeCategoria" minOccurs="0"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:maxLength value="50" /> </xs:restriction> </xs:simpleType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> </xs:choice> </xs:complexType> <xs:unique name="Constraint1" msdata:PrimaryKey="true"> <xs:selector xpath=".//Produtos" /> <xs:field xpath="ProdutoID" /> </xs:unique> <xs:unique name="Categorias_Constraint1" msdata:ConstraintName="Constraint1" msdata:PrimaryKey="true"> <xs:selector xpath=".//Categorias" /> <xs:field xpath="CategoriaID" /> </xs:unique> </xs:element></xs:schema>

Seu objetivo será 'destrinchar' estes arquivos, obter as informações e exibi-las em uma controle TreeView em uma aplicação Windows Forms.

Elementar não é mesmo ???

No arquivo estoque.xsd temos a definição de um dataset contendo as tabelas Categorias e Produtos e do relacionamento entre elas enquanto que no arquivo estoque.xml temos os dados.

A aplicação Windows Forms deverá exibir os dados conforme a figura abaixo:

Em um controle TreeViewrespectivos produtos relacionados.

Ao selecionar um produto é exibido em um controle Label a direita a sua descrição.

E para terminar a fase de definições, você deve usar a linguagem C#.

Eu vou usar o Visual Studio 2010 beta 2 (estou usando e abusando) e criar um projeto Windows Forms Application (Menu File -> New Project) usando a linguagem C# com o nome TreeViewDataBinding;

No formulário padrão form1.cs defina o leiaute conforme mostrado na figura abaixo:

Agora no formulário form1.cs defina o namespace System.Data pois vamos trabalhar com objetos Table, DataSet, DataRow, etc.;

using System.Data;

No formulário vamos criar também algumas classes para gerenciar as informações que serão obtidas a partir do arquivo XML e XSD.

Eu poderia ter criado as classes em um arquivo separado (seria mais aconselhável) mas resolvi criar no formulário mesmo para mostrar que podemos usar este recurso.

A seguir temos o código das classes:

public class ProdutoDataBase{

public class Tabelas{ //define as tabelas que iremos usas

public const string Produto = "Produtos";public const string Categoria = "Categorias";

}

public class ProdutoCampo{ //define os campos dos produtos que serão exibidos

public const string Nome = "NomeModelo";public const string Descricao = "Descricao";

}

public class CategoriaCampo{ //define o campo da categoria que será exibido

public const string Nome = "NomeCategoria";}

//define o dataSet e o DataRelation para o relacionamento das tabelas

private DataSet dsEstoque;DataRelation relCategoriaProduto;

public ProdutoDataBase(){ //cria uma instância do DataSet

dsEstoque = new DataSet();

try {

//lê o esquema e o arquivo XML que é a fonte de dados dsEstoque.ReadXmlSchema(Application.StartupPath + "\\

estoque.xsd"); dsEstoque.ReadXml(Application.StartupPath + "\\estoque.xml");

// Define o relacionamento entre Categorias e Produtos relCategoriaProduto = new DataRelation("Prod_Cat", dsEstoque.Tables["Categorias"].Columns["CategoriaID"], dsEstoque.Tables["Produtos"].Columns["CategoriaID"]); dsEstoque.Relations.Add(relCategoriaProduto);

} catch (Exception ex) {

MessageBox.Show(" Erro - A aplicação será encerrada : " + ex.Message);

Application.Exit(); } }

//obtem a tabela Categorias public DataTable getCategorias() { return dsEstoque.Tables["Categorias"]; }

//obtem o produto relacionado com a categoria public DataRow[] getProdutosNaCategoria(DataRow rowParent) { return rowParent.GetChildRows(relCategoriaProduto); }

//exibe a descrição do produto selecionado public string getExibeTexto(DataRow row) {

string text = "";switch (row.Table.TableName){

case Tabelas.Produto:text = "ID: " + row[0] + "\n";text += "Nome: " + row[ProdutoCampo.Nome]

+ "\n\n";text += row[ProdutoCampo.Descricao];break;

}return text;

}}

Na classe ProdutoDataBase temos definidos as seguintes classes:

Tabelas ProdutoCampo CategoriaCampo o construtor ProdutoDataBase getCategorias getProdutosNaCategoria getExibeTexto

Nesta classe estamos acessando os arquivos XML e XSD usando do método ReadXML do objeto DataSet além de dar o suporte para acessar os dados do arquivo XML.

Agora no início do formulário vamos criar uma instância dessa classe para usar no acesso e exibição do dados.

private ProdutoDataBase DataClass = new ProdutoDataBase();

A seguir no evento Load do formulário temos o código que acessa os dados no XML da tabela Categorias e as exibe no controle TreeView;

private void Form1_Load(object sender, System.EventArgs e){

TreeNode noPai;foreach (DataRow row in DataClass.getCategorias().Rows){

// Incluir o Nó CategorianoPai =

treeDB.Nodes.Add(row[ProdutoDataBase.CategoriaCampo.Nome].ToString());noPai.ImageIndex = 0;// Armazena a informação sobre a CategorianoPai.Tag = row;// Inclui um Nó noPai.Nodes.Add("*");

}}

A seguir no evento BeforeExpand do controle TreeView temos o código que armazena a informação sobre o  produto:

private void treeDB_BeforeExpand(object sender, System.Windows.Forms.TreeViewCancelEventArgs e){

TreeNode nodeSelected, nodeChild;nodeSelected = e.Node;if (nodeSelected.Nodes[0].Text == "*"){ // Limpa o Nó *

nodeSelected.Nodes.Clear();foreach (DataRow row in

DataClass.getProdutosNaCategoria((DataRow)nodeSelected.Tag)) {

nodeChild = nodeSelected.Nodes.Add(row[ProdutoDataBase.ProdutoCampo.Nome].ToString());

// Armazena a informação sobre ProdutonodeChild.Tag = row;nodeChild.ImageIndex = 1;nodeChild.SelectedImageIndex = 1;

} }

}

No evento AfterSelect do TreeView temos o código que exibe a informação sobre  o produto no controle Label - lblinfo:

private void treeDB_AfterSelect(object sender, System.Windows.Forms.TreeViewEventArgs e){ lblInfo.Text = DataClass.getExibeTexto((DataRow)e.Node.Tag);}

O código a seguir fecha a aplicação:

private void cmdClose_Click(object sender, System.EventArgs e){ this.Close();}

Dessa forma exibimos os dados de um arquivo XML em um controle TreeView.

Pegue o projeto completo aqui : TreeViewDataBinding.zip

Eu sei é apenas C#, mas eu gosto...

Referências:

VB .NET - Usando o controle TreeView VB. NET - Herança - criando controles herdados Usando TreeView na Pratica II VB - Exibindo tabelas e registros em um conntrole TreeView Usando o controle TreeView III Lendo um arquivo XML em um TreeView TreeView - Arrastar e Soltar (Drag and Drop) VB.NET - 'Espiando' o sistema de arquivos Criar banco de dados via Código - Access , SQL Server Tabelas: Trabalhando com tabelas (Access). Criando um Banco de dados com o VisData Criando banco de dados e tabelas com o Access

José Carlos Macoratti

C# - Conexão com os principais SGBD atuais via ADO .NET

Neste artigo eu vou mostrar (novamente) como você pode efetuar a conexão (apenas a conexão) com os principais Sistemas de gerenciadores de banco de dados (SGBD) atuais via ADO .NET usando a linguagem C#.

Por que eu estou voltando mais uma vez a esse assunto ?

É que constantemente recebo consultas e também vejo essa pergunta nos Fóruns, então resolvi de forma direta, simples e objetiva mostrar como fazer isso usando a linguagem C#.

Para começar eu vou indicar um link onde você vai encontrar as strings de conexão para os principais banco de dados : http://www.connectionstrings.com/

Creio que isso já bastasse para que o problema fosse resolvido mas eu vou pegar os principais banco de dados usados e mostrar como fazer a conexão, selecionar as informações e exibi-las em um controle DataGridView.

Para todos os exemplos mostrados aqui eu usei o SharpDevelop 3.2 (O Visual C# 2008 Express dará o mesmo resultado) onde criei um projeto do tipo Windows Forms e coloquei no formulário padrão um controle tabControl, um controle DataGridView (gdvDados) para e um controle Button(btnCarregaDadosNomeBancoDados) para cada banco de dados a ser testado;

Em todos os exemplos eu estou colocando o código para acessar o banco de dados no evento Click do botão Carregar Dados;(recomendo que você crie uma camada de acesso a dados)

Em todos os exemplos eu estarei usando o namespace System.Data;

De forma geral eu estou sempre definindo uma string de conexão, uma instrução SQL e criando um objeto Command e/ou DataAdapter para ambos e em seguida preenchendo o objeto DataTable para exibir os dados no Grid.

Alerto para o fato de que estarei mostrando uma das possíveis formas de se conectar com o banco de dados usando ADO .NET, não é a melhor nem a pior é uma das formas de fazer a conexão:

1- Acessando o Microsoft Access

Provedor usado : Microsoft Jet OLE DB 4.0namespace utilizado : System.Data.OledbBanco de dados : Northwind.mdb local: c:\dados tabela: Products

void BtnCarregarDadosAccessClick(object sender, EventArgs e){ try{ //cria um DataTabale DataTable dt = new DataTable(); //define a string de conexão com o MSAccess

string strConn = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\dados\Northwind.mdb;"; //Abre a conexão OleDbConnection conn = new OleDbConnection(strConn); //cria um DataAdapter selecionando os dados de um tabela do MSAccess OleDbDataAdapter da = new OleDbDataAdapter("Select * from Products", conn); //preenche o DataTable da.Fill(dt); //exibe os dados no DataGridView gdvDados.DataSource = dt.DefaultView; } catch (Exception ex) { MessageBox.Show("Erro : " + ex.Message); }}

2- Acessando o MySQL

Provedor usado : MySQL Connectornamespace utilizado : MySql.Data.MySqlClient;Banco de dados : Cadastro  tabela: Estoque

Obs: Incluir a referência ao provedor MySQL.Data

void CarregarDadosMySQLClick(object sender, EventArgs e){ MySqlConnection conn = null; try { string strConn = @"Server=localhost;Database=Cadastro;Uid=root;Pwd='numsey';Connect Timeout=30;"; //Abre a conexão conn = new MySqlConnection(strConn); conn.Open(); string mSQL = "Select * from Estoque"; //definindo o comando para a conexão a instrução SQL MySqlCommand cmd = new MySqlCommand(mSQL,conn); MySqlDataAdapter da = new MySqlDataAdapter(cmd); //preenchendo o objeto DataTable a partir do DataAdapter DataTable dt = new DataTable(); da.Fill(dt); this.gdvDadosMySQL.DataSource = dt; } catch (MySqlException msqle) { MessageBox.Show("Erro de acesso ao MySQL : " + msqle.Message,"Erro"); } finally { conn.Close(); }}

3- Acessando o SQL Server

Provedor usado : SQL Server .NET Data Providernamespace utilizado : System.Data.SqlClientBanco de dados : Northwind.mdf tabela: Products

void BtnCarregarDadosSQLServerClick(object sender, EventArgs e){ try{ //cria um DataTabale DataTable dt = new DataTable(); //define a string de conexão com o SQL Server string strConn = @"Server = .\sqlexpress;Database = NorthWind; Integrated Security = SSPI;"; //Abre a conexão SqlConnection conn = new SqlConnection(strConn); //cria um DataAdapter selecionando os dados de um tabela do SQL Server SqlDataAdapter da = new SqlDataAdapter("Select * from Customers", conn); //preenche o DataTable da.Fill(dt); //exibe os dados no DataGridView gdvDadosSQLServer.DataSource = dt.DefaultView; } catch (Exception ex) { MessageBox.Show("Erro : " + ex.Message); }}

 4- Acessando o Firebird

Provedor usado : FireBirdClientnamespace utilizado : FirebirdSql.Data.FirebirdClient;Banco de dados : EMPLOYEE.FDB local: c:\dados tabela: EMPLOYEE

Obs: Incluir a referência ao provedor FireBirdSQLData.FireBirdClient

void BtnCarregarDadosFireBirdClick(object sender, EventArgs e){ string strConn = @"DataSource=localhost; Database=C:\dados\

EMPLOYEE.FDB; UserId=SYSDBA; Pwd=masterkey"; FbConnection fbConn = new FbConnection(strConn); //define o objeto comando para a instrução SQL e a conexão FbCommand fbCmd = new FbCommand("Select * from EMPLOYEE",fbConn); try { fbConn.Open(); //cria um DataAdpater e preenche o DataTable FbDataAdapter fbDa = new FbDataAdapter(fbCmd); DataTable dtEmployee = new DataTable(); fbDa.Fill(dtEmployee);

gdvDadosFireBird.DataSource = dtEmployee; } catch (FbException fbex) { MessageBox.Show("Erro ao acessar o FireBird " + fbex.Message,"Erro"); } finally { fbConn.Close(); }}

5- Acessando o SQLite

Provedor usado : System.Data.SQLite.dllnamespace utilizado : System.Data.SQLite;Banco de dados : MacorattiSQLite.db local: c:\dados tabela: Alunos;

void CarregarDadosSQLiteClick(object sender, EventArgs e){ try{ DataTable dt = new DataTable();

String insSQL = "select * from Alunos"; String strConn = @"Data Source=C:\dados\MacorattiSQLite.db";

SQLiteConnection conn = new SQLiteConnection(strConn); //define o objeto DataAdater para a instrução SQL e a conexão SQLiteDataAdapter da = new SQLiteDataAdapter(insSQL,strConn); //preenche o DataTable da.Fill(dt); gdvDadosSQLite.DataSource = dt.DefaultView; } catch(Exception ex) { MessageBox.Show("Erro ao acessar o SQLite " + ex.Message,"Erro"); }}

Creio que fui bem objetivo. E estamos conversados...

Eu sei é apenas C#  mas eu gosto...

Referências:

C# - Acessando Ms Access C# - Acessando uma tabela Access C# - Acessando MySQL C# - Gerenciando um banco de dados MySQL C# - Acessando FireBird

José Carlos Macoratti