E-Book 650 Dicas e Truques de Python - PDF com 1.200 páginas
Você está aqui: C# ::: C# + Bancos de Dados ::: DbDataReader

Saiba mais sobre o funcionamento de um DataReader

Quantidade de visualizações: 15300 vezes
Quando pensamos em efetuar uma conexão C# com um banco de dados e listar os registros de uma determinada tabela, um DataReader (na verdade o nome da classe é DbDataReader) é o terceiro componente na lista daqueles necessários para efetuar tal tarefa.

O primeiro componente que precisamos é DbConnection, uma classe abstrata que tem entre suas classes derivadas as classes OdbcConnection, OleDbConnection, OracleConnection, SqlConnection e SqlCeConnection. Um objeto de uma classe que descende de DbConnection é o responsável por obter e manter a conexão com o banco de dados.

O segundo componente é aquele que permite "conversar" com o banco de dados, a saber, um objeto da classe DbCommand. Entre as classes que derivam de DbCommand podemos citar OdbcCommand, OleDbCommand, OracleCommand, SqlCommand e SqlCeCommand. Usamos objetos da classe DbCommand para enviar instruções SQL ao banco de dados.

Uma vez conectados ao banco de dados e com uma instrução SELECT pronta para ser executada, é preciso que tenhamos um componente que guarde os registro retornados pela instrução SELECT. Este componente é, em boa parte das aplicações, um DataReader.

Um DataReader é um objeto que implementa a interface System.Data.IDataReader. Este componente permite obter os dados retornados por um DbCommand em forma de registros (um registro por linha). Os dados mantidos no componente são de leitura rápida, mas, de mão única e somente leitura. Por mão única entendemos que os dados são lidos apenas em uma direção, ou seja, um DataReader não permite voltar ao registro anterior.

Veja um trecho de código no qual efetuamos uma conexão com o banco de dados, disparamos um comando SELECT e obtemos os registros retornados em um DbDataReader (usei um OdbcDataReader porque me conectei a um banco de dados MySQL usando ODBC):

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

private void button1_Click(object sender, EventArgs e){
  // obtém a conexão com o banco de dados
  OdbcConnection conn = ConexaoODBC.obterConexao();

  // string para auxiliar na exibição dos dados lidos
  string temp = "Registros retornados:\n\n";

  if(conn != null){
    // obtém todos os clientes cadastrados
    OdbcCommand cmd = new OdbcCommand("SELECT * FROM clientes", 
      conn);

    // obtém os dados retornados em forma de DataReader
    OdbcDataReader dr = cmd.ExecuteReader();

    // vamos exibir os dados de cada cliente encontrado
    while(dr.Read()){
      temp += dr["id"].ToString() + " ::: ";
      temp += dr["nome"].ToString() + " ::: ";
      temp += dr["cidade"].ToString() + " ::: ";
      temp += dr["estado"].ToString() + "\n";
    }

    // fecha o DataReader
    dr.Close();
    
    // fecha a conexão
    ConexaoODBC.fecharConexao();

    // exibe o resultado
    MessageBox.Show(temp);
  }
}

Neste exemplo usei ODBC. Se estiver usando SQL Server, use as classes correspondentes (SqlConnection, SqlCommand e SqlDataReader). Note que um DataReader é sempre obtido como resultado de uma chamada ao método ExecuteReader() da classe DbCommand:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// obtém os dados retornados em forma de DataReader
OdbcDataReader dr = cmd.ExecuteReader();

Quando o comando SQL é enviado ao banco de dados e um DataReader é retornado, seu cursor é posicionado antes do primeiro registro. Assim, é preciso efetuar chamadas ao seu método Read() para que o cursor seja posicionado no próximo registro. Quando o método retornar false saberemos que não há mais registros a serem lidos. Por esta razão, um laço while é quase sempre usado neste cenário:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// vamos exibir os dados de cada cliente encontrado
while(dr.Read()){
  temp += dr["id"].ToString() + " ::: ";
  temp += dr["nome"].ToString() + " ::: ";
  temp += dr["cidade"].ToString() + " ::: ";
  temp += dr["estado"].ToString() + "\n";
}

Cada registro contido no DataReader é composto de uma coleção de objetos. Cada objeto representando um campo na tabela. Os objetos desta coleção podem ser acessados por índices (começando em 0) ou pelo nome do campo na tabela. Neste exemplo usamos o método de acessar cada objeto usando o nome do campo.

Link para compartilhar na Internet ou com seus amigos:

C# ::: Desafios e Lista de Exercícios Resolvidos ::: Laços

Exercícios Resolvidos de C# - Escreva um programa (algorítmo) C# que usa o laço do...while para ler um número indeterminado de idades. A condição de parada do laço é o valor da idade igual a 0

Quantidade de visualizações: 1616 vezes
Pergunta/Tarefa:

Escreva um programa (algorítmo) C# que usa o laço do...while para ler um número indeterminado de idades de algumas pessoas. A condição de parada do laço é o valor da idade igual a 0. Calcule a escreva a idade média deste grupo de pessoas.

Sua saída deverá ser parecida com:

Informe a idade: 19
Informe a idade: 30
Informe a idade: 21
Informe a idade: 45
Informe a idade: 0
A idade média é: 28,75
Resposta/Solução:

Veja a resolução comentada deste exercício usando C# console:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

using System;

namespace Estudos {
  class Program {
    static void Main(string[] args) {
      int idade; // guarda a idade lida de cada indivíduo
      double idade_media; // a idade média calculada
      int soma = 0; // a soma das idades de cada indivíduo
      int contador = 0; // conta as idades lidas

      // laço do...while que repetirá até que o valor da idade seja 0
      do {
        Console.Write("Informe a idade: ");
        idade = int.Parse(Console.ReadLine());

        // a idade lida é diferente de 0?
        if (idade != 0) {
          soma = soma + idade; // soma mais esta idade
          contador++; // aumenta a quantidade de idades lidas
        }
      } while (idade != 0);

      // calcula a idade média
      // note que forcei contador para o tipo double antes da divisão
      // isso faz com que o resultado seja do tipo double
      idade_media = soma / (contador * 1.0);

      // finalmente mostramos o resultado
      Console.WriteLine("A idade média é: " + idade_media);
    
      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}



C# ::: Dicas & Truques ::: Gráficos

Como desenhar gráficos em C# usando GDI+ - Computação gráfica em C# - Passos inicias

Quantidade de visualizações: 16808 vezes
Qualquer um que queira iniciar os estudos e desenhos de gráficos em C# usando Windows Forms deve obrigatoriamente entender um pouco de GDI e GDI+. GDI é o acrônimo de Graphics Device Interface e GDI+ é o seu sucessor em versões mais recentes do Microsoft Windows. Com a indepedência do GDI+ podemos desenhar em um formulário, na tela ou impressora sem qualquer modificação no código. O próprio GDI+ se encarrega dos detalhes da implementação de cada um destes diferentes dispositivos.

O GDI+ é uma interface de programação de aplicações (API) que forma o sub-sistema do sistema operacional Microsoft Windows XP. Esta API é a responsável pela exibição de informações na tela e impressoras. O GDI+ é uma DLL Win32 chamada de gdiplus.dll que é distribuída com o Windows XP e versões mais recentes do Windows. Esta DLL está também disponível para uso em versões do Windows anteriores ao XP.

A plataforma .NET encapsula as funcionalidades do GDI+ nos seguintes namespaces: System.Drawing, System.Drawing.Drawing2D, System.Drawing.Imaging, System.Drawing.Text e System.Drawing.Printing.

Antes de iniciar seus desenhos em C# e Windows Forms, é importante entender o sistema de coordenadas do GDI+. Este sistema usa a medida de pixels ("picture elements"), que é a menor unidade de resolução no display de um monitor. Assim, o canto superior esquerdo de um controle GUI (um formulário, um painel, botão, etc) tem as coordenadas (0, 0), ou seja, x = 0 e y = 0. Lembre-se de que x é o eixo horizontal e y é o eixo vertical.

A classe Graphics, do pacote System.Drawing, é quem fornece boa parte dos métodos que usamos para desenhar em C# e Windows Forms. Veja sua posição na hierarquia de classes da plataforma .NET:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

System.Object 
  System.MarshalByRefObject 
    System.Drawing.Graphics

Um objeto desta classe pode ser obtido com uma chamada ao método CreateGraphics() a partir de um objeto que herda de System.Windows.Forms.Control ou gerenciando o evento Paint do controle e acessando a propriedade Graphics da classe System.Windows.Forms.PaintEventArgs.

Veja um trecho de código no qual desenhamos uma linha horizontal no formulário a partir do clique de um botão:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

private void button1_Click(object sender, EventArgs e){
  // vamos obter o Graphics do formulário
  Graphics g = this.CreateGraphics();

  // vamos desenhar uma linha horizontal de 300 pixels na
  // cor preta e espessura de 1 pixel
  g.DrawLine(new Pen(Color.Black, 1), new Point(20, 80), 
    new Point(320, 80));

  // vamos liberar o objeto Graphics
  g.Dispose();
}



C# ::: Namespace System.Windows.Forms ::: Formulários e Janelas

Como usar a classe Form em suas aplicação C# Windows Form

Quantidade de visualizações: 786 vezes
A classe Form é usada para representar as janelas (formulários) ou caixas de diálogo que compõem a interface gráfica de uma aplicação Windows Forms. Veja sua posição na hierarquia de classes da plataforma.NET:

System.Object 
  System.MarshalByRefObject 
    System.ComponentModel.Component 
      System.Windows.Forms.Control 
        System.Windows.Forms.ScrollableControl 
          System.Windows.Forms.ContainerControl 
            System.Windows.Forms.Form


É importante conhecer algumas classes derivadas da classe Form. Entre estas classes podemos citar:

- System.ComponentModel.Design.CollectionEditor.CollectionForm
- System.Messaging.Design.QueuePathDialog
- System.ServiceProcess.Design.ServiceInstallerDialog
- System.Web.UI.Design.WebControls.CalendarAutoFormatDialog
- System.Web.UI.Design.WebControls.RegexEditorDialog
- System.Windows.Forms.Design.ComponentEditorForm
- System.Windows.Forms.PrintPreviewDialog
- System.Windows.Forms.ThreadExceptionDialog

Uma aplicação Windows Forms em C# é construida a partir de uma ou mais janelas. A classe Form permite criar formulários padrões, de ferramentas, sem bordas e flutuantes, cada um direcionado a uma determinada funcionalidade. É possível também usar a classe Form para criar caixas de diálogo modais.

Há ainda um tipo especial de janela (ou formulário) conhecido como formulário de interface de múltiplos documentos (MDI) que contêm outros formulários chamados de filhos (MDI child forms). Uma janela do tipo MDI pode ser criada definindo-se o valor true para a propriedade IsMdiContainer da classe Form. Os formulários filhos MDI são criados definindo-se o nome do formulário-pai para a propriedade MdiParent do formulário que atuará como filho.

Por meio das propriedades disponíveis na classe Form nós podemos determinar a aparência, tamanho, cor e os aspectos de gerenciamento da janela do formulário ou caixa de diálogo que estamos criando. A propriedade Text permite definir o título da janela. As propriedades Size e DesktopLocation permitem definir o tamanho e posição inicial da janela. A propriedade ForeColor define a cor do texto padrão de todos os componentes colocados no formulário. As propriedades FormBorderStyle, MinimizeBox e MaximizeBox permitem definirmos se o formulário poderá ser minimizado, maximizado ou redimensionado em tempo de execução.

Além das propriedades, podemos usar os métodos da classe Form. Por exemplo, podemos usar o método ShowDialog() para exibir um formulário como uma caixa de diálogo modal. Podemos também efetuar uma chamada ao método SetDesktopLocation() para posicionar o formulário em uma determinada região do desktop.

Os eventos disponíveis na classe Form permitem responder às ações realizadas no formulário. Podemos, por exemplo, usar o evento Activated para realizar operações tais como atualizar as informações exibidas nos controles do formulário quando este for ativado.

Se estiver usando o Visual Studio 2005, 2008 ou mais recente, o formulário inicial de sua aplicação Windows Forms C# já será exibido inicialmente seguinte os seguintes passos:

a) Vá no menu File -> New -> Project;
b) Em Project types selecione Visual C# -> Windows;
c) Em Templates selecione Windows Application;
d) Dê um nome para o projeto, escolha um local, um nome para a solução e clique OK. Imediatamente o projeto será criado e você já verá o formulário principal da aplicação.
e) Vá em View -> Toolbox. Clique e arraste alguns componentes para o formulário;
f) Pressione F5 e execute a aplicação.

Pronto! Agora é só verificar todas as dicas, truques e anotações para aprender e tirar proveito total da classe Form.


C# ::: Fundamentos da Linguagem ::: Estruturas de Controle

Como usar a instrução de salto incondicional goto da linguagem C#

Quantidade de visualizações: 17370 vezes
A instrução goto na linguagem C# é uma instrução de salto incondicional. Quando esta instrução é encontrada, o fluxo de execução de código salta imediatamente para a localização definida pelo goto. Embora não muito usada, esta instrução, ás vezes, tem sua utilidade.

A instrução goto exige um rótulo (label), que é um identificador C# válido seguido por dois pontos. Além disso, este rótulo deve estar dentro do mesmo método no qual a instrução goto estará contida. Isso quer dizer que não é possível usar goto para saltar de um método para outro. Veja um trecho de código no qual usamos goto para contar de 0 até 10:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

using System;

namespace Estudos{
  class Program{
    static void Main(string[] args){
      int valor = 0;

      // define o rótulo para o goto
      inicio:

      // exibe os números de 0 até 10
      if (valor <= 10){
        Console.WriteLine("{0}", valor);
        valor++;
        goto inicio;
      }

      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

Ao executar este código nós teremos o seguinte resultado:

0
1
2
3
4
5
6
7
8
9
10

Pressione uma tecla para sair...

É claro que este código, ainda que seja um bom exemplo do uso de goto, pode e deve ser substituído por um laço for ou while. Lembre-se: goto é usado somente em casos nos quais nenhuma outra instrução ou construção esteja disponível.

Veja, por exemplo, como podemos usar goto para saltar entre as cláusulas case de uma instrução switch:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

using System;

namespace Estudos{
  class Program{
    static void Main(string[] args) {
      for (int i = 1; i < 3; i++) {
        switch (i) {
          case 1:
            Console.WriteLine("Estou na cláusula 1.");
            goto case 3;
          case 2:
            Console.WriteLine("Estou na cláusula 2.");
            goto case 1;
          case 3:
            Console.WriteLine("Estou na cláusula 3.");
            goto default;
          default:
            Console.WriteLine("Estou na cláusula padrão.");
            break;
        }
      }

      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

Ao executar este código nós teremos o seguinte resultado:

Estou na cláusula 1.
Estou na cláusula 3.
Estou na cláusula padrão.
Estou na cláusula 2.
Estou na cláusula 1.
Estou na cláusula 3.
Estou na cláusula padrão.

Outro uso útil da instrução goto é quando precisamos sair de um laço profundamente aninhado (três ou quatro níveis já é uma tarefa complicada). Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

using System;

namespace Estudos{
  class Program{
    static void Main(string[] args) {
      int i = 0, j = 0, k = 0;

      for (i = 0; i < 10; i++) {
        for (j = 0; j < 10; j++) {
          for (k = 0; k < 10; k++) {
            Console.WriteLine("i, j, k: " + i + " " +
              j + " " + k);
            if (k == 3) goto parada;
          }
        }
      }

    // rótulo de parada
    parada:
      Console.WriteLine("Parei! i, j, k: " + i + " " +
        j + " " + k);

      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}


Ao executar este exemplo nós teremos o seguinte resultado:

i, j, k: 0 0 0
i, j, k: 0 0 1
i, j, k: 0 0 2
i, j, k: 0 0 3
Parei! i, j, k: 0 0 3

Para finalizar, tenha em mente que goto é usado para sair de um bloco de instruções. Tentar usar esta instrução para saltar para dentro de um bloco de instruções é um erro de síntaxe e o seu código não compilará.


C# ::: Coleções (Collections) ::: ArrayList

Como passar uma ArrayList para um método C#

Quantidade de visualizações: 9105 vezes
Em algumas situações nós precisamos fornecer uma ArrayList para um método C# e manipulá-la a partir deste método. Nesta dica eu mostro como isso pode ser feito.

Veja que, dentro do método Main da aplicação nós criamos um novo objeto da classe ArrayList e inserimos 5 números inteiros nela. Em seguida nós efetuamos uma chamada ao método exibirArrayList() passando a lista como referência, ou seja, qualquer alteração que fizermos na ArrayList dentro do método afetará também o objeto criado fora do método.

Veja o código completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

using System;
using System.Collections;

namespace Estudos {
  class Program {
    static void Main(string[] args) {
      // Cria o ArrayList
      ArrayList lista = new ArrayList();

      // Adiciona 5 inteiros
      lista.Add(30);
      lista.Add(2);
      lista.Add(98);
      lista.Add(1);
      lista.Add(7);

      // passa o ArrayList para um método que exibirá
      // seus valores
      exibirArrayList(lista);

      Console.WriteLine("\n\nPressione qualquer tecla para sair...");
      // pausa o programa
      Console.ReadKey();
    }

    // método que receberá e exibirá o conteúdo do ArrayList
    static void exibirArrayList(ArrayList mLista) {
      foreach (int valor in mLista) {
        Console.Write("{0} ", valor);
      }
    }
  }
}

Ao executar este código C# nós teremos o seguinte resultado:

30 2 98 1 7


Desafios, Exercícios e Algoritmos Resolvidos de C#

Veja mais Dicas e truques de C#

Dicas e truques de outras linguagens

Quem Somos

Osmar J. Silva
Programador Freelancer
WhatsApp +55 (062) 98553-6711

Goiânia-GO
Programador Freelancer - Full Stack Developer, Professional Java Developer, PHP, C/C++, Python Programmer, wxWidgets Professional C++ Programmer, Freelance Programmer. Formado em Ciência da Computação pela UNIP (Universidade Paulista Campus Goiânia) e cursando Engenharia Civil pela PUC-Goiás. Possuo conhecimentos avançados de Java, Python, JavaScript, C, C++, PHP, C#, VB.NET, Delphi, Android, Perl, e várias tecnologias que envolvem o desenvolvimento web, desktop, front-end e back-end. Atuo há mais de 20 anos como programador freelancer, atendendo clientes no Brasil, Portugal, Argentina e vários outros paises.
Entre em contato comigo para, juntos, vermos em que posso contribuir para resolver ou agilizar o desenvolvimento de seus códigos.
José de Angelis
Programador Freelancer
WhatsApp +55 (062) 98243-1195

Goiânia-GO
Programador Freelancer - Formado em Sistemas de Informação pela Faculdade Delta, Pós graduado em Engenharia de Software (PUC MINAS), Pós graduado Marketing Digital (IGTI) com ênfase em Growth Hacking. Mais de 15 anos de experiência em programação Web. Marketing Digital focado em desempenho, desenvolvimento de estratégia competitiva, analise de concorrência, SEO, webvitals, e Adwords, Métricas de retorno. Especialista Google Certificado desde 2011 Possui domínio nas linguagens PHP, C#, JavaScript, MySQL e frameworks Laravel, jQuery, flutter. Atualmente aluno de mestrado em Ciência da Computação (UFG)
Não basta ter um site. É necessário ter um site que é localizado e converte usuários em clientes. Se sua página não faz isso, Fale comigo e vamos fazer uma analise e conseguir resultados mais satisfatórios..

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais


© 2024 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 86 usuários muito felizes estudando em nosso site.