SQLite Datenbanken in C# Applikationen verwenden
System.Data.SQlite aus dem Hause phxsoftware bietet eine Schnittstelle zur Verwendung von portablen Datenbanken im SQLite Format. Im Folgenden möchte ich zeigen, wie man diese auf unterschiedlicher Weise, in C# Applikationen verwenden kann.
Um eine SQLite Datenbank zu erstellen, gibt es eine Menge von Managementapplikationen oder auch Browsererweiterungen, z.b für den Firefox. Ich verwende, um mir erstmalig eine Datenbank zu erstellen, den kostenlosen SQLiteBrowser. Die erstellte Datenbank speichere ich dann in meinem TestProjekt, mit welchem ich auf diese zugreifen möchte.
Als erstes holen wir uns die Installation oder die Binaries. Je nach Architektur wird dann im Projekt, auf die entsprechende dll referenziert. Ich verwende die System.Data.SQLite.dll für x86, welche sich im bin Ordner befindet.
SQLiteCommand
Im ersten Beispiel, verwende ich die SQLiteCommand-Klasse, um auf die Datenbank zugreifen.
Nach dem Einbinden des Namespace “using System.Data.SQLite;” stehen uns die Klassen SQLiteConnection und SQLiteCommand zur Verfügung. (Mehr benötigen wir erstmal in unserem Beispiel nicht.)
Den Pfad, zur zuvor angelegten Datenbank lege ich in der app.config fest, damit dieser konfigurierbar bleibt:
1 2 3 4 5 | <configuration> <appSettings> <add key="DATASOURCE" value="../../DataBase/data" /> </appSettings> </configuration> |
im Code dann (namens DataProvider.cs), holen wir uns den Pfad über den ConfigurationManager in eine KlassenVariable. Hier muss explizit auf System.Configuration referenziert werden
1 | private string DataSource = ConfigurationManager.AppSettings.Get("DATASOURCE"); |
Das Speichern, Emitteln und Löschen erledigen wir über das SQLiteCommand. Zum Öffnen und Schließen der SQLiteConnection habe ich mir zwei Methoden geschrieben:
1 2 3 4 5 6 7 8 | SQLiteConnection connection; private void OpenConnection() { connection = new SQLiteConnection(); connection.ConnectionString = "Data Source=" + DataSource; connection.Open(); } |
1 2 3 4 5 | private void CloseConnection() { connection.Close(); connection.Dispose(); } |
Speichern von Einträgen
1 2 3 4 5 6 7 8 9 10 11 | OpenConnection(); using (var command = new SQLiteCommand(connection)) { command.CommandText = string.Format("INSERT INTO Entities (Beschreibung, HtmlName, Unicode, Zeichen) VALUES('{0}', '{1}', '{2}', '{3}')", entity.Beschreibung, entity.HtmlName, entity.Unicode, entity.Zeichen); command.ExecuteNonQuery(); } CloseConnection(); |
Ermitteln von Einträgen
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 | OpenConnection(); List<HtmlEntity> entities = new List<HtmlEntity>(); using (var command = new SQLiteCommand(connection)) { command.CommandText = "SELECT * FROM Entities"; using (SQLiteDataReader reader = command.ExecuteReader()) { while (reader.Read()) { entities.Add(new HtmlEntity { Beschreibung = reader[0].ToString(), HtmlName = reader[1].ToString(), Unicode = reader[2].ToString(), Zeichen = reader[3].ToString() }); } reader.Close(); } } CloseConnection(); |
Löschen von Einträgen
1 2 3 4 5 6 7 8 9 10 11 | OpenConnection(); using (var command = new SQLiteCommand(connection)) { command.CommandText = string.Format("DELETE FROM Entities WHERE Beschreibung = '{0}' AND HtmlName = '{1}' AND Unicode = '{2}' AND Zeichen = '{3}'", entity.Beschreibung, entity.HtmlName, entity.Unicode, entity.Zeichen); command.ExecuteNonQuery(); } CloseConnection(); |
Achtung! Es ist möglich, das die SQLite Assembly sich nicht mit dem 4.0 .NET kompilieren lässt. (Mixed mode assembly is built against version ‘v2.0.50727′ of the runtime and cannot be loaded in the 4.0 runtime without additional configuration information), hier kann man sich aber mit folgendem Eintrag, innerhalb des “configuration-Knoten” in der app.config behelfen
1 2 3 | <startup useLegacyV2RuntimeActivationPolicy="true"> <supportedRuntime version="v4.0"/> </startup> |
Tipp via: stackoverflow
SQLite & Entity Framework
Es ist auch möglich, eine SQLite Datenbank als Datensource für ein Entity-Framework-Model anzugeben. Das erstelle Entity FrameworkModel stellt uns nun den Kontext bereit, Einträge zu persistieren, zu ermitteln und zu löschen.
Eintrag speichern
1 2 3 4 5 6 7 8 | public void InsertData(HtmlEntity entity) { using (var context = new HtmlEntityEntities()) { context.AddToEntities(entity); context.SaveChanges(); } } |
Einträge ermitteln
1 2 3 4 5 6 7 8 9 10 11 12 13 | public List<HtmlEntity> GetAllHtmlEntities() { List<HtmlEntity> entities; using (var context = new HtmlEntityEntities()) { entities = (from e in context.Entities select e).ToList(); } return entities; } |
Eintrag löschen
1 2 3 4 5 6 7 8 9 10 11 | public void DeleteData(HtmlEntity entity) { using (var context = new HtmlEntityEntities()) { HtmlEntity obj = (HtmlEntity)context.GetObjectByKey(entity.EntityKey); context.DeleteObject(obj); context.SaveChanges(); } } |
LINQ to SQLite
Wie wir an den EF Methoden gesehen haben, können wir nun einfach mit LINQ die Operationen ausführen.
Am Beispiel “Einträge ermitteln” wurde LINQ bereits verwendet, diese kann dann natürlich auch durch eine Where-Klausel erweitert werden:
1 2 3 4 5 6 | using (var context = new HtmlEntityEntities()) { return (from e in context.Entities where e.Beschreibung == keyword select e).FirstOrDefault(); } |
Auch wenn es so scheint, dass die System.Data.SQLite.Linq.dll wichtig für den Zugriff mit LINQ ist, wir benötigen diese dll nicht, denn durch das generieren des EF Models, steht uns hier LINQ aus dem Framework zu Verfügung.
Fragen? Einfach in den Kommentaren damit. Viel Spaß beim entwickeln : )
