Visual Studio 2010 (Express) – Linq 2 SQLite2Entities

In diesem Artikel möchte ich einmal zeigen wie ein Datenbank-Zugriff auf eine SQLite Datenbank Anhand eines Entity-Modelles funktioniert und wie man darauf dann über Linq zugreifen kann.

Das Entity-Modell erstelle ich direkt im Visual Studio 2010.
Hierfür benutze ich absichtlich die Express-Version des Visual Studio um zu zeigen das es in dieser auch funktioniert.

Als erstes einmal brauchen wir den ADO.NET SQLite Provider für das VS2010 und dem .NET4.0 Framework.
Der Installer ist momentan noch etwas versteckt im Forum des Anbieters zu finden, da es noch keine wirkliche Öffentliche Version davon gibt.
Hier der Direkt-Download: http://sqlite.phxsoftware.com/forums/storage/29/9252/SQLite-1.0.66.1-vs2010-net4.zip

Meine Test-Datenbank soll ein paar Fimen mit Adressen speichern.
Die Struktur dieser sieht wie folgt aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
CREATE TABLE [firmen] (
  [id] INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, 
  [name] VARCHAR(50), 
  [email] VARCHAR(50), 
  [tel] VARCHAR(50), 
  [notizen] text);
 
CREATE TABLE [adressen] (
  [id] INTEGER PRIMARY KEY AUTOINCREMENT, 
  [name] VARCHAR(50), 
  [nachname] VARCHAR(50), 
  [email] VARCHAR(50), 
  [geb] DATE, 
  [info] teXT, 
  [id_firmen] INTEGER(11));

Der Inhalt der Tabellen sieht in etwa so aus:

id name   email          tel  notizen      
-- ------ -------------- ---- ------------ 
 1 firma1 info@firma1.de 1111 erste firma  
 2 firma2 info@firma2.de 2222 zweite firma 
 3 firma3 info@firma3.de 3333 dritte firma 
 4 firma4 info@firma4.de 4444 vierte firma
id name    nachname email                    geb        info          id_firmen 
-- ------- -------- ------------------------ ---------- ------------- --------- 
 1 Sven    Einzer   sven.einzer@firma1.de    1983-05-08 Mitarbeiter 1         1 
 2 Maik    Zweier   maik.zweier@firma2.de    1980-05-12 Mitarbeiter 2         2 
 3 Fred    Dreier   fred.dreier@firma3.de    1955-03-23 Mitarbeiter 3         3 
 4 Hendrik Einzer   hendrik.einzer@firma1.de 1945-03-05 Mitarbeiter 4         1 
 5 Beate   Zweier   beate.zweier@firma2.de   1980-04-03 Mitarbeiter 5         2 
 6 Holger  Dreier   holger.dreier@firma3.de  1987-02-05 Mitarbeiter 6         3 
 7 Verona  Einzer   verona.einzer@firma1.de  1954-08-03 Mitarbeiter 7         1 
 8 Melanie Vierer   melanie.vierer@firma4.de 1992-06-09 Mitarbeiter 8         4 
 9 Stefan  Vierer   stefan.vierer@firma4.de  1991-10-10 Mitarbeiter 9         4

Nachdem wir nun den ADO.net Provider für SQLite installiert haben und er sich ins VS2010 eingenistet hat und eine kleine SQLite DB aufgebaut haben, können wir nun mit einem neuen Projekt starten.

Das Ziel ist es erstmal anhand eines Entity-Modells auf die Datenbank zugreifen zu können und später auch Linq auf dieses Model anwenden zu können.
Also brauchen wir für unser Projekt ein Entity Model.
Dieses Model soll die Datenbank für uns in Entities greifbar machen.

In den Projekt-Item-Templates findet sich so etwas:

Das sieht hübsch aus, das sieht neu aus, das sieht Interessant aus – das nehmen wir (und fügen es unserem Projekt hinzu) 🙂
Als Name wähle ich einfach mal „db.edmx“, da unsere Datenbank da drin liegen soll.

Nach dem erstellen der Datei wird gefragt wie man das Model generieren möchte.
Da wir eine Datenbank haben, möchten wir es auch aus dieser generiert haben:

Nun kann man seine Datenbank einrichten…
Bei mir sieht das fertig in etwa so aus:

Im nächsten Fenster wird gefragt was genau man generiert haben möchte.
Ich habe einfach mal alles ausgewäht:

Wenn wir das alles übernehmen, haben wir 2 Entities der 2 tabellen in der Datenbank.
Das ganze sieht dann in etwa so aus:

Das können wir jetzt so erst mal speichern und schließen 🙂

So…
Ich möchte jetzt den Inhalt der Tabellen auch Anzeigen können.
Jetzt wär es cool, wenn ich mir aus dem Entity ein Objekt erstellen könnte, womit ich direkt arbeiten kann.
Warum nicht einfach machen? 🙂

Ich öffne mir das Fenster für die Datenquellen, sieht so aus:

Und füge hier eine neue Datenquelle hinzu. Diese kommt aus einem Objekt (dem Entity).
Also folgendes auswählen:

Und dann die die Objekte „firmen“ und „adressen“ auswählen:

Und schwupps, werden sie als GUI-Objekte mit im den Datenquellen Gelistet:

Hier kann ich einfach oben z.B. das DatagridView nehmen und auf meine Form setzen.
Diese sieht dann in etwa so aus:

Eine BindingSource und ein BindungNavigator wurde gleich mit angelegt – praktisch!

Was wir jetz brauchen sind nur noch 2 Zeilen Code, z.b. im Load der Form:

1
2
3
4
5
        private void Form1_Load(object sender, EventArgs e)
        {
            testDBEntities db = new testDBEntities();
            firmenBindingSource.DataSource = db.firmen;
        }

Wenn wir das nun debuggen, wird uns höchst wahrscheinlich folgendes Bild angezeigt werden:

Was ist hier nun passiert?
Ganz einfach!
Die GUI Elemte sind an den Entities gebunden.
Der Inhalt der Entities kommt aus der Datenbank.
und die Datenbank wird standardmäßig mit dem ConnectionString in der App.config instanziiert.

Jetzt möchte ich aber z.b. den Connectionstring nicht in der Ap.config haben, weil die Datenbank dynamisch wärend der Laufzeit geladen werden soll – was also dafür tun?
Auch hierfür gibt es eine Lösung.
Man kann sich mit Hilfe der EntityConnectionStringBuilder-Klasse ein gleichnamiges Objekt bauen und dieses verwenden.

Mein Umgeschrebener Code sieht dann in etwa so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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.EntityClient;
 
namespace EFTest
{
    public partial class Form1 : Form
    {
        private testDBEntities db;
 
        public Form1()
        {
            InitializeComponent();
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            db = DBOPEN(@"C:\visual studio 2010\Projects\EFTest\testDB.db3");
            firmenBindingSource.DataSource = db.firmen;
        }
 
        private testDBEntities DBOPEN(string Pfad)
        {
            EntityConnectionStringBuilder conn = new EntityConnectionStringBuilder();
            conn.Provider = "System.Data.SQLite";
            conn.Metadata = "res://*/";
            conn.ProviderConnectionString = "data source=" + Pfad + "";
            EntityConnection con = new EntityConnection(conn.ToString());
 
            return new testDBEntities(con);
        }
    }
}

Jetzt wollen wir noch ein wenig Linq machen.
Ein gängiger Praxisfall wäre jetzt, wenn man auf eine Reihe der Tabelle mit den Firmen klickt und dann dementsprechend die Mitarbeiter angezeigt bekommt.

Hier für nehmen wir das Adressen-Grid aus den Datenquellen und ziehen es auf die Form.
Ein AdressenBindungSource-Objekt wurde gleich mit angelegt.

Jetzt brauchen wir noch ein CellClick event:

1
2
3
4
5
6
7
8
9
10
11
12
13
        private void firmenDataGridView_CellClick(object sender, DataGridViewCellEventArgs e)
        {
            // Erstmal müssen wir die Firmen-ID herausfinden, um die Mitabeiter anzeigen zu lassen
            int firmid = Convert.ToInt32(firmenDataGridView.Rows[e.RowIndex].Cells[0].Value);
 
            // Hier ist das Linq, welches die Mitarbeiter aus der Tabelle adressen sucht :)
            var res = from tAdressen in db.adressen
                      where tAdressen.id_firmen == firmid
                      select tAdressen;
 
            // Hier wird das ergebnis an die Datasource der adressenBindungSource gebunden!
            adressenBindingSource.DataSource = res;
        }

Wenn wir das nun ausführen, sieht es so aus:

Man sieht schön, das nur die Mitarbeiter zu der angeklicken Firma angezeigt werden.

Jetzt wär es natürlich noch klasse, wenn man Datensätze hinzufügen, ändern und speichern könnte!
Auch das ist ohne viel Aufwand verbunden 🙂

Wir ziehen uns einfach einen Button auf die Form und schreiben in den Click-Event diese Zeile Code:

1
2
3
4
        private void button1_Click(object sender, EventArgs e)
        {
            db.SaveChanges();
        }

Das war es!
Einmal durch kompilieren und ausprobieren bitte!

Man sieht – eine Firma5 angelegt mit 2 Mitarbeitern.
Die ID´s (Auto-INC) wurden beim Speichern automatisch vergeben.

Funktioniert alles bestens 🙂

Um was sind wir nun schlauer?
SQLite ist immernoch voll toll 🙂
SQLite kann mit Entities umgehen!
Man kann mit Linq auf SQLite zugreifen!
…und das alles funktioniert auch mit dem Visual Studio Express 🙂

Danke Microsoft! Danke SQLIte Team! Danke ihr ADO.NET SQLite Entwickler! 😀

2 Responses to Visual Studio 2010 (Express) – Linq 2 SQLite2Entities

  1.  

    22 Oha…:D hat bestimmt lange gedauert das alles hier aufzubauen oder ?

  2.  

    Hallo,
    Ich komme leider nicht weiter bei der Verbindung zu meiner sqlite.db bekomme ich diese Fehlermeldung:
    Object reference not set to an instance of an object.

    Habe schon im web gesucht! Vielleicht hast du ja nen tipp.
    Gruß
    Christina

leave your comment


*

Unterstütze den Frickelblog!