ADO.net : Connected klassen

  1. Inleiding
  2. Managed Providers
  3. SQL Server
  4. OLEDB
  5. Verbinden met Oledb
  6. Verbinden met SQL Server
  7. SQL Server: SqlCommand
  8. SQL Server: SqlDataReader
  9. SQL Server: DataSet en SqlDataAdapter
  10. Parameters in queries
  11. SQL Server: Stored Procedures

Inleiding

ADO.net bevat klassen die je kan gebruiken om data te transfereren tussen een database en een client applicatie. Er zijn veel verschillende soorten databases, dit betekent dat je gespecialiseerde code nodig hebt om de brug te slaan tussen de disconnected dataklassen en de database.

Managed Providers

Managed Providers zijn een verzameling van klassen die in het .net Framework de basis vormen van het ADO.net programmeermodel. De Managed Data Providers bevatten klassen die voor het volgende kunnen gebruikt worden: Er zijn nog vele ander providers beschikbaar voor uiteenlopende database-systemen.

SQL Server

ADO.net klassen voor SQL Server - System.Data.SqlClient

Klasse Omschrijving
SqlConnection Vertegenwoordigt een open verbinding naar een SQL-server gegevensbron
SqlDataAdapter Vertegenwoordigt een verzameling gegevensopdrachten en een databaseverbinding om het ADO.net-object DataSet te vullen.
SqlCommand Vertegenwoordigt een T-SQL instructie of een Stored Procedure die SQL Server uitvoert.
SqlParameter Wordt gebruikt om parameters mee te geven aan het object SqlCommand.
SqlError Verzamelt informatie over foutmeldingen die een ADO.net toepassing tegenkomt.

OLE DB

Klassen voor OLE DB gegevensbronnen - System.Data.OleDb

Klasse Omschrijving
OleDbConnection Vertegenwoordigt een open verbinding naar een gegevensbron
OleDbCommand Vertegenwoordigt een SQL-query die op een gegevensbron moet worden uitgevoerd
OleDbDataReader Correspondeert met een forward-only, read-only Recordset. Het is een in hoge mate geoptimaliseerde interface om de resultaten van een query uitgevoerd te krijgen op een gegevensbron
OleDbDataAdapter Vertegenwoordigt een verzameling gegevensopdrachten en een databaseverbinding die worden gebruikt om een DataSet te vullen en de gegevensbron te updaten
OleDbParameter Vertegenwoordigt een parameter die met een OleDbCommand-object wordt doorgegeven
OleDbError Vertegenwoordigt de fouten die door de gegevensbron worden gegenereerd

Verbinden met een OLEDB-gegevensbron

Database biblio_2000.mdb downloaden

Hier zie je een voorbeeld om met behulp van een DataReader-object gegevens uit een Access mdb-file in een ListBox te plaatsen. 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.OleDb;

namespace Connected
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void btnVulLijst_Click(object sender, EventArgs e)
        {
            //OleDbConnection object maken
            OleDbConnection dbconn = new OleDbConnection();
            //ConnectieString instellen
            dbconn.ConnectionString = @"Provider=Microsoft.Jet.OLEDB.4.0;
                                        Data Source=D:\Csharp\ADONET\adonet\Connected\biblio_2000.mdb";

            //object om straks te lezen uit de database
            OleDbDataReader dbread = null;

            try
            {
                //Databaseverbinding openen
                dbconn.Open();

                //SQL-code om gegevens uit de database te halen
                string sql = "Select * from auteur";

                //Command object aanmaken, sql en connectie meegeven
                OleDbCommand dbcom = new OleDbCommand(sql, dbconn);

                //DataReader-object aanmaken (fast-foward, read-only toegang)
                //en vullen
                dbread = dbcom.ExecuteReader();

                //met de methode Read lezen we een record uit de tabel
                //de velden uit de tabel zijn genummerd vanaf 0
                while (dbread.Read())
                {
                    lstData.Items.Add(dbread.GetString(1).ToString() +
                        " (" + dbread.GetInt32(0).ToString() + ")");
                }

            }
            catch (OleDbException ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                //geef resources vrij
                if (dbread != null) dbread.Close();
                if (dbconn != null) dbconn.Close();
            }

        }
    }
}

Daar wij als standaarddatabase een SQL-server database gaan gebruiken blijft dit deel beperkt.

OLE DB tutorial bij MSDN

SQL Server: SqlConnection

Database Spionshop mdf downloaden

Database Spionshop aanmaakscript (exe)

Database Spionshop aanmaakscript (.sql-files)

Belangrijk: je kan aan een SQL Server Express geen twee databases attachen met dezelfde naam, m.a.w. kies 1 van bovenstaande mogelijkheden, beide samen zal leiden tot fouten.

Connectiestring SQL Server 2008 Express - file database 

SqlConnection conn = new SqlConnection(
        @"Data Source=.\SQLEXPRESS;
          AttachDbFilename=|DataDirectory|spionshop.mdf;
          Integrated Security=true"
        );

Connectiestring SQL Server - Windows Authentication

SqlConnection conn = new SqlConnection(
        @"Data Source=(local);
                      Initial Catalog=Spionshop;
                      Integrated security=true"
        );

(local) geldt voor een SQL-Server geïnstalleerd op de lokale computer, desnoods vervangen door het adres van de gewenste SQL-Server.
Voor een database die reeds attached is aan SQL Express op de lokale machine kan je als Data Source .\sqlexpress opgeven i.p.v. een runtime te attachen file database uit vorig voorbeeld.

Connectiestring SQL Server - SQL Server Authentication

SqlConnection conn = new SqlConnection(
        @"Data Source=(local);
                      Initial Catalog=Spionshop;
                      Integrated security=false;
					  uid=gebruikersnaam;
					  pwd=pwd"
        );

(local) geldt voor een SQL-Server geïnstalleerd op de lokale computer, desnoods vervangen door het adres van de gewenste SQL-Server Een SqlConnection-object vertelt ADO.net met welke server en database je zal gaan werken. Het regelt de communicatie tussen jouw toepassing en SQL-server.
De informatie die dient om toegang te krijgen tot SQL-server (servernaam, databasenaam, gebruikersnaam, paswoord, ...) zit vervat in een tekenreeks die we de ConnectionString noemen. Om concreet te verbinden met een SQL Server database hebben we een dus een ConnectionString nodig (voor OLE DB was dit ook het geval).

Een ConnectionSting kan volgende informatie bevatten (in zogenaamde naam=waarde paren):

String-onderdeel Omschrijving
Data Source Identificeert de server: servernaam, IP-adres of (local) voor lokale server.
Initial Catalog of Database Naam van de database op de server
Integrated Security Stel in op SSPI om gebruik te maken van je Windows gebruikersgegevens
User ID (uid) Gebruikersnaam
Password (pwd) Paswoord voor de gebruikte User ID
AttachDbFilename Voor SQL Server 2005 Express: pad naar het bestand, je kan ook met de aanduiding |DataDirectory| werken. Dan wordt de datamap, of standaard de root-map van het project aangewend.

Application configuration

Je kan de connectiestring(s) ook bewaren in een configuratiebestand voor je applicatie: App.config, voor ASP.Net toepassingen is dat Web.config. Het grote voordeel is dat je wanneer de connectiestring verandert, je enkel een nieuw configuratiebestand hoeft te maken, de toepassing moet niet hercompileerd te worden.

Voorbeeldtoepassing

In deze toepassing maken we verbinding met een lokale SQL Server en gebruiken we een SqlDataReader om de gegevens te ontvangen in onze toepassing.

Tip! Open in Visual Studio.net de Server Explorer om de SQL Server / Express te raadplegen. 

App.config
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <clear />
    <add name="spionshop" 
         providerName="System.Data.SqlClient" 
        connectionString="Data Source=.\SQLEXPRESS;
                          AttachDbFilename=|DataDirectory|spionshop.mdf;
                          Integrated Security=true"/>
  </connectionStrings>
</configuration>

Form1.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Configuration;

namespace Connected
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //SqlConnection object maken
            
            SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Spionshop"].ToString());

            //object om straks te lezen uit de database
            SqlDataReader rdr = null;

            try
            {
                //Databaseverbinding openen
                conn.Open();

                //SQL-code om gegevens uit de database te halen
                string sql = "Select * from klant";

                //Command object aanmaken, sql en connectie meegeven
                SqlCommand cmd = new SqlCommand(sql, conn);

                //DataReader-object aanmaken (fast-foward, read-only toegang)
                //en vullen
                rdr = cmd.ExecuteReader();


                while (rdr.Read())
                {
                    lstData.Items.Add(rdr.GetString(1).ToString() +
                        " " + rdr.GetString(2).ToString() +
                        " (" + rdr.GetInt16(0).ToString() + ")");
                }

            }
            catch (SqlException ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                //geef resources vrij
                if (rdr != null) rdr.Close();
                if (conn != null) conn.Close();
            }

        }
    }
}

SQL Server: SqlCommand

SqlCommand cmd = new SqlCommand("select * from klant", conn);
Met het SqlCommand-object kan je instellen welk soort operatie je met de database gaat ondernemen. Je kan bijvoorbeeld een select, insert, delete of update commando geven.

Enkele waarde opvragen

//Maak een SqlCommand aan met de gewenste query
 SqlCommand cmd = new SqlCommand("select max(klant_id) from klant", conn);
 
//Vraag de waarde op met de methode ExecuteScalar
 short max = (short)cmd.ExecuteScalar();

Het gegevenstype short (Int16) uit c# komt overeen met smallint uit SQL-Server.

Data opvragen

//Maak een SqlCommand aan met de gewenste query
SqlCommand cmd = new SqlCommand("select * from klant", conn);

//Met de methode ExecuteReader haal je de resultaten op
SqlDataReader rdr = cmd.ExecuteReader();
Deze code werd in het voorbeeld hierboven reeds toegepast

Data invoegen

// commandostring voorbereiden
 string insertString = @"
     insert into klant
     (klant_id, naam, voornaam)
     values (200, 'naamKlant','voornaamKlant')";
 
 // instantie van SqlCommand met de query en de connectie
 SqlCommand cmd = new SqlCommand(insertString, conn);
 
 // voer de methode ExecuteNonQuery uit: geen retourwaarde verwacht
 cmd.ExecuteNonQuery();

Data updaten

// commandostring voorbereiden
string updateString = @"
       update klant
       set naam = 'xxxx' , voornaam = 'yyyy'
       where klant_id = 200";
 
// instantie van SqlCommand met de query en de connectie
SqlCommand cmd = new SqlCommand(updateString, conn);
 
// voer de methode ExecuteNonQuery uit: geen retourwaarde verwacht
cmd.ExecuteNonQuery();

Data verwijderen

// commandostring voorbereiden
 string deleteString = @"
     delete from klant
     where klant_id = 200";
 
 // instantie van SqlCommand met de query en de connectie
 SqlCommand cmd = new SqlCommand(deleteString, conn);
 
 // voer de methode ExecuteNonQuery uit: geen retourwaarde verwacht
 cmd.ExecuteNonQuery();

Voorbeeldtoepassing

We maken een kleine toepassing waar we de verschillende SQL-querytypes gebruiken. 

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Data.SqlClient;

namespace SQLServer
{
    /// <summary>
    /// Summary description for Form1.
    /// </summary>
    public class Form1 : System.Windows.Forms.Form
    {
        private System.Windows.Forms.ListBox lstData;
        private System.Windows.Forms.Button btnNieuw;
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;
        private SqlConnection conn = new SqlConnection(
            "Data Source=(local);Initial Catalog=Spionshop;" +
            "User ID=spion;Password=spionpas");
        private System.Windows.Forms.Button btnVerwijder;
        private System.Windows.Forms.Button btnUpdate;
		
        //object om straks te lezen uit de database
        private SqlDataReader rdr = null;
		//Id voor de nieuwe klant
        private short nieuwKlantId;

        ...

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

        private void VulLstData()
        {
            //Maak de lijst leeg
            lstData.Items.Clear();

            try
            {
                //Databaseverbinding openen
                conn.Open();
            
                //SQL-code om gegevens uit de database te halen
                string sql = "Select * from klant";

                //Command object aanmaken, sql en connectie meegeven
                SqlCommand cmd = new SqlCommand(sql,conn);

                //DataReader-object aanmaken (fast-foward, read-only toegang)
                //en vullen
                rdr = cmd.ExecuteReader();


                while(rdr.Read())
                {
                    lstData.Items.Add(rdr.GetString(1).ToString() +
                        " " +rdr.GetString(2).ToString() +
                        " (" +rdr.GetInt16(0).ToString() +")");
                }
                
            }
            catch(SqlException ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                //geef resources vrij
                if (rdr != null) rdr.Close();
                if (conn != null) conn.Close();
            }
        }

        private void btnNieuw_Click(object sender, System.EventArgs e)
        {
            try 
            {
                conn.Open();
                //Maak een SqlCommand aan met de gewenste query
                SqlCommand cmd = new SqlCommand("select max(klant_id) from klant", conn);
 
                //Vraag de waarde op met de methode ExecuteScalar
                nieuwKlantId = (short)cmd.ExecuteScalar(); 
                nieuwKlantId++;


                // commandostring voorbereiden
                // een enkele quote meegeven in SQL: 2 enkele quotes tikken
                string insertString = @"
                    insert into klant
                    (klant_id, naam, voornaam)
                    values (" +nieuwKlantId +", 'D''Hondt','Guy')";
 
   
                cmd = new SqlCommand(insertString, conn);
 
                // voer de methode ExecuteNonQuery uit: geen retourwaarde verwacht
                cmd.ExecuteNonQuery(); 
            }
            catch(SqlException ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                //geef resources vrij
                if (conn != null) conn.Close();
            }

            VulLstData();
            btnNieuw.Enabled = false;
            btnUpdate.Enabled = true;
        
        }

        private void btnVerwijder_Click(object sender, System.EventArgs e)
        {
            try 
            {
                conn.Open();
                // commandostring voorbereiden
                string deleteString = @"
                    delete from klant
                    where klant_id = " +nieuwKlantId;
 
                // instantie van SqlCommand met de query en de connectie
                SqlCommand cmd = new SqlCommand(deleteString, conn);
 
                // voer de methode ExecuteNonQuery uit: geen retourwaarde verwacht
                cmd.ExecuteNonQuery(); 
            }
            catch(SqlException ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                //geef resources vrij
                if (conn != null) conn.Close();
            }

            VulLstData();
            btnVerwijder.Enabled = false;
            btnNieuw.Enabled = true;
        }

        private void btnUpdate_Click(object sender, System.EventArgs e)
        {
            try 
            {
                conn.Open();
                // commandostring voorbereiden
                string updateString = @"
                    update klant
                    set naam = 'xxxx' , voornaam = 'yyyy'
                    where klant_id = " +nieuwKlantId;
 
                // instantie van SqlCommand met de query en de connectie
                SqlCommand cmd = new SqlCommand(updateString, conn);
 
                // voer de methode ExecuteNonQuery uit: geen retourwaarde verwacht
                cmd.ExecuteNonQuery(); 
            }
            catch(SqlException ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                //geef resources vrij
                if (conn != null) conn.Close();
            }

            VulLstData();
            btnUpdate.Enabled = false;
            btnVerwijder.Enabled = true;
        
        }
    }
}

SQL Server: SqlDataReader

SqlDataReader rdr = cmd.ExecuteReader();

In de vorige voorbeelden hebben we de SqlDataReader reeds gebruikt, we gaan er hier wat dieper op in.
Met een SqlDataReader kan je gegevens op een forward-only, read-only manier lezen. Met een SqlDataReader kan je dus niet terugkeren naar vorige records, je kan de waarden in de database ook niet beïnvloeden (verwijderen, veranderen).

Je kan met een SqlDataReader gegevens opvragen door de kolommen te specifiëren met de naam of het volgnummer van de kolom: 

while (rdr.Read())
	{
		// resultaten uit de kolommen halen
		short id = (short)rdr["klant_id"]
		string naam = (string)rdr["naam"];
		string voornaam = (string)rdr["voornaam"];
	}
of 
while (rdr.Read())
	{
		// resultaten uit de kolommen halen
		short id = (short)rdr.GetInt16(0);
		string naam = rdr.GetString(1);
		string voornaam = rdr.GetString(2);
	}
De methode Read van de SqlDataReader positioneert zich op de volgende record en retourneert true als er nog een record is, false indien op het einde gekomen.

SQL Server: DataSet en SqlDataAdapter

Een DataSet is een geheugenobject dat meerdere tabellen en hun onderlinge relaties kan bevatten. DataSet houdt enkel data vast, maar interageert niet met een Data Source. Het is de SqlDataAdapter die je toegang verleent tot een Data Source en zorgt voor een niet-verbonden interactie. Een SqlDataAdapter zal dus zelf zorgen voor het openen en sluiten van de connectie op het gepaste ogenblik.

Een SqlDataAdapter doet volgende acties bij het vullen van een DataSet met gegevens:

  1. Open connectie
  2. Ontvang gegevens in DataSet
  3. sluit connectie

Een SqlDataAdapter doet volgende acties bij het updaten van gegevens:

  1. Open connectie
  2. Update gegevens: schrijf veranderingen in DataSet weg in Data Source
  3. sluit connectie

Een SqlDataAdapter maken

SqlDataAdapter daKlant = new SqlDataAdapter(
    "select * from klant", conn);

Hier heb je dus een SqlConnection object voor nodig, dit moet gedeclareerd zijn maar nog niet geopend. Het openen en sluiten van de SqlConnection zal de SqlDataAdapter voor zijn rekening nemen.

Een DataSet maken

DataSet dsKlant = new DataSet();

SqlCommandBuilder

Je merkt dat je bij aanmaken van de SqlDataAdapter een select-instructie opgeeft om aan te geven hoe de gegevens moeten worden opgehaald.
Je kan echter ook update, delete en insert-mogelijkheden aan de SqlDataAdapter toevoegen. Dit kan voor de eenvoudigste gevallen (waarden uit 1 tabel, zonder joins) met een SqlCommandBuilder: 

SqlCommandBuilder cmdBldr = new SqlCommandBuilder(daKlant);
De SqlCommandBuilder cmdBldr leest de select-routine in de SqlDataAdapter daKlant en genereert zelf de update, delete en insert-instructies en koppelt deze aan de methode Update van de SqlDataAdapter daKlant.
Voor meer gecompliceerde acties zal je anders moeten werken, dit komt later in de cursus aan bod.

De SqlDataSet vullen

We beschikken nu over alle manipulaties die we nodig hebben, tijd om de DataSet dsKlant te vullen met de gegevens uit de Data Source, dit doen we met de methode Fill van de SqlDataAdapter: 

daKlant.Fill(dsKlant, "Klanten");

Het tweede argument is de naam waaronder deze gegevens beschikbaar zullen zijn in de DataSet. Als de gegevens uit 1 tabel komen gebruik je meestal gewoon de naam van de tabel, je mag ook zelf een naam verzinnen. Geef je geen naam op dan krijgt de tabel de naam Table1 (verder worden tabellen oplopend genummerd).

Een DataSet gebruiken

Om een DataSet te gebruiken kan je deze binden aan een Windows.Form DataGridView of een ASP.net GridView. 

dgKlant.DataSource = dsKlant; 
dgKlant.DataMember = "Klanten";

We stellen eerst de eigenschap DataSource van de DataGridView in op de DataSet dsKlant. Daar deze DataSet meerdere gegevenstabellen kan bevatten geven we in de eigenschap DataMember van de DataGrid de naam in van de gegevenstabel Klanten.

Gegevens updaten

daKlant.Update(dsKlant, "Klanten");
Met de methode Update van de SqlDataAdapter kunnen we de veranderde gegevens terugpushen naar de DataSource.

Voorbeeldtoepassing

In deze toepassing plaatsen we een DataGridView dgKlant in een Windows Forms applicatie. Behalve de naam van de DataGridView stel je geen eigenschappen in via de Properties in Visual Studio. We zullen in deze eerste toepassing de code zelf schrijven, merk op dat je met behulp van VS veel code automatisch zou kunnen laten genereren. 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Configuration;

namespace Connected
{
    public partial class Form3 : Form
    {
        private SqlConnection conn;
        private SqlDataAdapter daKlant;
        private DataSet dsKlant;

        //tabelnaam voor de Adapter, is niet noodzakelijk...
        private const string tabelnaam = "Klanten";

        public Form3()
        {
            InitializeComponent();
        }

        private void Form3_Load(object sender, EventArgs e)
        {
            //data-objecten vullen
            InitData();

            //datagrid koppelen
            dgKlant.DataSource = dsKlant;
            dgKlant.DataMember = tabelnaam;

        }

        public void InitData()
        {
            // connectie maken
            conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Spionshop"].ToString());

            // DataSet instantieren
            dsKlant = new DataSet();

            // Adapter maken met sql-instructie en connectie
            daKlant = new SqlDataAdapter("select klant_id, naam, voornaam from Klant", conn);

            // insert, update, and delete vullen
            SqlCommandBuilder cmdBldr = new SqlCommandBuilder(daKlant);

            // dataset vullen
            daKlant.Fill(dsKlant, tabelnaam);
        }

        private void btnUpdate_Click(object sender, EventArgs e)
        {
            daKlant.Update(dsKlant, tabelnaam);
        }
    }
}

Parameters in queries

Wanneer je werkt met gegevens wil je deze vaak filteren op basis van een criterium. Aangezien de SQL-instructie die je meegeeft aan een SqlCommand een string is kan je deze string dynamisch opbouwen: 

SqlCommand cmd = new SqlCommand(
		"select * from Klant where woonplaats = '" 
		+ strWoonPlaats + "'";
Deze manier van werken is af te raden! Dikwijls komen de gegevens die je op die manier in een SQL-instructie stopt uit bv. een TextBox. Kwaadwillende gebruikers kunnen dit misbruiken door een SQL-instructie op te bouwen die destructieve gevolgen heeft, of bedrijfsgeheimen te grabbel gooit.

Het is bijgevolg een veel veiliger manier om te werken met parameters. Op deze manier heeft je veldgegevens mee en sta je de gebruiker niet toe om het even welke SQL-instructie op de database los te laten.

Een SqlCommand voorbereiden op het gebruik van parameters

// declareer een command met een parameter
	SqlCommand cmd = new SqlCommand(
		"select * from Klant where woonplaats = @Woonplaats", conn);

Een SqlParameter-object aanmaken

// definiëer parameters
	SqlParameter param  = new SqlParameter();
	param.ParameterName = "@Woonplaats";
	param.Value         = strWoonPlaats;

Koppel de SqlParameter aan een SqlCommand

// Koppel de SqlParameter aan een SqlCommand
	cmd.Parameters.Add(param);

Voorbeeldtoepassing

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Data.SqlClient;

namespace SQLServer
{

    public class Form1 : System.Windows.Forms.Form
    {

        private System.ComponentModel.Container components = null;
        private SqlConnection conn = new SqlConnection(
            "Data Source=(local);Initial Catalog=Spionshop;" +
            "User ID=spion;Password=spionpas");
        //object om straks te lezen uit de database
        private SqlDataReader rdr = null;
        private System.Windows.Forms.Label lbl;
        private System.Windows.Forms.TextBox txtWoonplaats;



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

        private void VulLstData()
        {
            //Maak de lijst leeg
            lstData.Items.Clear();

            try
            {
                //Databaseverbinding openen
                conn.Open();
            
                //SQL-code om gegevens uit de database te halen
                string sql = "Select * from klant where woonplaats like @Woonplaats";

                //Command object aanmaken, sql en connectie meegeven
                SqlCommand cmd = new SqlCommand(sql,conn);

                // Parameter aanmaken - 
                // % is een jokerteken voor SQL-server: 
                //     reeks van willekeurige tekens, mag ook 0 zijn.
                SqlParameter param  = new SqlParameter();
                param.ParameterName = "@Woonplaats";
                param.Value         = txtWoonplaats.Text +"%";

                // Parameter toevoegen aan command
                cmd.Parameters.Add(param);


                //DataReader-object aanmaken (fast-foward, read-only toegang)
                //en vullen
                rdr = cmd.ExecuteReader();


                while(rdr.Read())
                {
                    short id = (short)rdr.GetInt16(0);
                    string naam = rdr.GetString(1);
                    string voornaam = rdr.GetString(2);
                    lstData.Items.Add(rdr.GetString(1).ToString() +
                        " " +rdr.GetString(2).ToString() +
                        " (" +rdr.GetInt16(0).ToString() +")");
                }
                
            }
            catch(SqlException ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                //geef resources vrij
                if (rdr != null) rdr.Close();
                if (conn != null) conn.Close();
            }
        }


        private void txtWoonplaats_TextChanged(object sender, System.EventArgs e)
        {
            VulLstData();
        }

        
    }
}

SQL Server: Stored Procedures

Stored Procedure aanmaken, SQL Server: Query Analyzer

In de voorbeelddatabase Spionshop voorzien we een Stored Procedure "Drie duurste producten": 
create procedure "Drie duurste producten" AS
SET ROWCOUNT 3
SELECT artikel, verkoopprijs
FROM artikel
ORDER BY verkoopprijs DESC

Stored Procedure uitvoeren

// SqlCommand maken die de Stored Procedure identificeert
SqlCommand cmd  = new SqlCommand(
		"Drie duurste producten", conn);

// Stel de eigenschap CommandType van het SqlCommand correct in
// StoredProcedure is een element uit de enum CommandType
cmd.CommandType = CommandType.StoredProcedure;

Parameters doorgeven aan een Stored Procedure

Maak in SQL Server volgende Stored Procedure in de database Spionshop: 
CREATE  PROCEDURE ArtikelUitCategorie @CatID smallint
AS
SELECT artikel, omschrijving, verkoopprijs
FROM artikel
WHERE cat_id = @CatID
ORDER BY artikel

Je kan de Stored Procedure aanroepen en een parameter meegeven: 

// SqlCommand maken die de Stored Procedure identificeert
SqlCommand cmd  = new SqlCommand(
		"ArtikelUitCategorie", conn);

// Stel de eigenschap CommandType van het SqlCommand correct in
// StoredProcedure is een element uit de enum CommandType
cmd.CommandType = CommandType.StoredProcedure;

// Voeg SqlParameter toe aan Command, deze wordt doorgegeven aan de Stored Procedure
cmd.Parameters.Add(new SqlParameter("@CatID", catid));

Voorbeeldtoepassing

In deze toepassing gaan we een stapje verder dan de beschreven theorie, en ontvangen we het resultaat van een Stored Procedure met inputparameter (de STP ArtikelUitCategorie - zie hierboven) in een DataSet.
We vullen de DataSet met behulp van een SqlDataAdapter die de database connecteert op basis van een Stored Procedure.
Deze DataSet koppelen we dan aan een DataGrid.

Je kan een DataGrid ook rechtstreeks koppelen aan een SqlDataReader: 

SqlDataReader dr = myCommand.ExecuteReader();
MyDataGrid.DataSource = dr;


using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Data.SqlClient;

namespace SQLServer
{
    public class Form1 : System.Windows.Forms.Form
    {
        private System.ComponentModel.Container components = null;
        private SqlConnection conn = new SqlConnection(
            "Data Source=(local);Initial Catalog=Spionshop;" +
            "User ID=spion;Password=spionpas");
        private System.Windows.Forms.ListBox lstCategorie;
        private System.Windows.Forms.DataGrid dgArtikel;
        //object om straks te lezen uit de database
        private SqlDataReader rdr = null;
        
        //structure die een categorie voorstelt
        public struct Categorie
        {
            public short catid;
            public string naam;

            public Categorie(short catid, string naam)
            {
                this.catid = catid;
                this.naam = naam;
            }

            public override string ToString()
            {
                return naam;
            }


        }

        ...

        private void Form1_Load(object sender, System.EventArgs e)
        {
            VulLstCategorie();
			//indien mogelijk eerste item in categorielijst selecteren
            if(lstCategorie.Items.Count >0) lstCategorie.SelectedIndex = 0;

            
        }
		
		//Categorielijst vullen
        private void VulLstCategorie()
        {
            try
            {
                //Databaseverbinding openen
                conn.Open();
            
                //SQL-code om gegevens uit de database te halen
                string sql = "Select * from Categorie";

                //Command object aanmaken, sql en connectie meegeven
                SqlCommand cmd = new SqlCommand(sql,conn);

                //DataReader-object aanmaken (fast-foward, read-only toegang)
                //en vullen
                rdr = cmd.ExecuteReader();


                while(rdr.Read())
                {
                    short id = (short)rdr["cat_id"];
                    string naam = (string)rdr["categorie"];
                    lstCategorie.Items.Add(new Categorie(id,naam));
                }
                
            }
            catch(SqlException ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                //geef resources vrij
                if (rdr != null) rdr.Close();
                if (conn != null) conn.Close();
            }
        }

		//DataGrid vullen met resultaat van Stored Procedure
        private void VulDgArtikel()
        {
            try
            {
                // geselecteerd catid uitlezen uit keuzelijst
                short catid = ((Categorie)lstCategorie.SelectedItem).catid;
                
                // object om DataSet te vullen: SqlAdapter
                SqlDataAdapter daArt = new SqlDataAdapter("ArtikelUitCategorie", conn);
                
                // Door het CommandType van het SelectCommand van de SqlDataAdapter
                // geven we aan dat we met een STP gaan werken voor het vullen van de DataSet
                daArt.SelectCommand.CommandType = CommandType.StoredProcedure;
                
                // Parameter voor de STP invoegen
                daArt.SelectCommand.Parameters.Add("@CatID", catid);

                // Dataset declareren en vullen
                DataSet dsArt = new DataSet();
                daArt.Fill(dsArt,"Artikels");

                // Met een DataSet de DataGrid bevolken
                dgArtikel.DataSource = dsArt;
                dgArtikel.DataMember = "Artikels"; 

                // CaptionText instellen van de DataGrid
                // SelectedItem retourneert een struct Categorie, de ToString methode
                // wordt automatisch uitgevoerd en retourneert de naam van de categorie
                dgArtikel.CaptionText = "Artikels uit de categorie " +lstCategorie.SelectedItem;
            }
            catch(SqlException ex)
            {
                MessageBox.Show(ex.Message);
            }
        }


        private void lstCategorie_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            
            if(lstCategorie.SelectedIndex != -1) VulDgArtikel();
        }    
    }
}

Visual Studio.net

Om met een gegevensproject te werken met Visual Studio.net biedt GotDotNet een aantal kant en klare projectvoorbeelden aan. Probeer dit zeker eens uit !

Meer tutorials:
leer ook: html | xhtml | css | asp | asp.net | c# | ado.net | linq | ajax | java | javascript
Valid HTML 4.01! Valid CSS! © - Cursusweb