C# SQLite (Wie es für Entwickler funktioniert)

Einführung in SQLite

SQLite ist eine in sich geschlossene, serverlose und konfigurationsfreie Datenbank-Engine, die in verschiedenen Anwendungen eingesetzt wird, darunter Desktop-, Web- und mobile Anwendungen. In diesem Tutorial werden wir uns mit der Verwendung von SQLite mit C# beschäftigen. Anhand einfacher und leicht verständlicher Beispiele lernen Sie, wie Sie eine SQLite-Datenbank erstellen, verwalten und mit ihr interagieren.

Was ist SQLite?

SQLite ist eine leichtgewichtige und effiziente Datenbank, die Daten in einer einzigen Datei speichert. Im Gegensatz zu herkömmlichen Datenbanken benötigt sie keinen separaten Server. Das macht es zu einer guten Wahl für Anwendungen, die eine Datenbank benötigen, ohne die Komplexität eines vollwertigen Datenbanksystems.

Einrichten von SQLite in C#

NuGet-Paketmanager verwenden

Um mit SQLite in einem C#-Projekt zu arbeiten, müssen Sie die notwendige SQLite-Bibliothek installieren. Dies kann über den NuGet Package Manager erfolgen.

1. Öffnen Sie Visual Studio und erstellen Sie eine neue Konsolenanwendung.

2. Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie "NuGet-Pakete verwalten"

3. Suchen Sie nach "SQLite" und installieren Sie das Paket.

Herstellen einer Verbindung

Verbindungszeichenfolge

Eine Verbindungszeichenfolge ist eine Zeichenfolge, die Informationen über eine Datenquelle und die Mittel zur Herstellung einer Verbindung zu ihr angibt. In SQLite sieht der Verbindungsstring oft wie folgt aus:

string connectionString = "Data Source=mydatabase.db;";

string connectionString = "Data Source=mydatabase.db;";

Dim connectionString As String = "Data Source=mydatabase.db;"

Verbindung Objekt

Sie können ein Verbindungsobjekt mit der Datenquelle "new SQLiteConnection" erstellen.

using SQLite;
var connection = new SQLiteConnection(connectionString);

using SQLite;
var connection = new SQLiteConnection(connectionString);

Imports SQLite
Private connection = New SQLiteConnection(connectionString)

Erstellen einer Tabelle

Tabelle erstellen

Das Erstellen einer Tabelle ist bei der Arbeit mit einer Datenbank von grundlegender Bedeutung. So erstellen Sie eine Tabelle mit SQLite-Code.

string query = "CREATE TABLE person (id INTEGER PRIMARY KEY, name TEXT)";
var command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();

string query = "CREATE TABLE person (id INTEGER PRIMARY KEY, name TEXT)";
var command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();

Dim query As String = "CREATE TABLE person (id INTEGER PRIMARY KEY, name TEXT)"
Dim command = New SQLiteCommand(query, connection)
command.ExecuteNonQuery()

• Id Ganzzahliger Primärschlüssel: Legt die Spalte "id" als Primärschlüssel fest.
• Tabellenname: Der Name, den Sie Ihrer Datenbanktabelle geben möchten.

Einfügen von Daten

Zeilen einfügen

Um Daten in eine Tabelle einzufügen, müssen Sie einen INSERT-Befehl verwenden.

string query = "INSERT INTO person (name) VALUES ('John')";
var command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();

string query = "INSERT INTO person (name) VALUES ('John')";
var command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();

Dim query As String = "INSERT INTO person (name) VALUES ('John')"
Dim command = New SQLiteCommand(query, connection)
command.ExecuteNonQuery()

Parametrierter Befehl

Parametrisierte Befehle können Ihre Anwendung vor SQL-Injection-Angriffen schützen. Bei diesem Ansatz werden Parameter verwendet, anstatt Werte direkt in die Abfrage einzufügen.

string query = "INSERT INTO person (name) VALUES (@name)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@name", "Iron Developer");
command.ExecuteNonQuery();

string query = "INSERT INTO person (name) VALUES (@name)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@name", "Iron Developer");
command.ExecuteNonQuery();

Dim query As String = "INSERT INTO person (name) VALUES (@name)"
Dim command = New SQLiteCommand(query, connection)
command.Parameters.AddWithValue("@name", "Iron Developer")
command.ExecuteNonQuery()

Abrufen von Daten

Erklärung auswählen

Um Daten aus der Datenbanktabelle abzurufen, verwenden Sie eine SELECT-Anweisung.

string query = "SELECT * FROM person";
var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();
while (reader.Read())
{
    Console.WriteLine(reader ["name"]);
}

string query = "SELECT * FROM person";
var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();
while (reader.Read())
{
    Console.WriteLine(reader ["name"]);
}

Dim query As String = "SELECT * FROM person"
Dim command = New SQLiteCommand(query, connection)
Dim reader = command.ExecuteReader()
Do While reader.Read()
	Console.WriteLine(reader ("name"))
Loop

Erweiterte Funktionen

SQLite-Transaktionen

Mit Transaktionen können Sie mehrere Vorgänge in einer einzigen atomaren Aktion ausführen. Hier erfahren Sie, wie Sie Transaktionen nutzen können:

var transaction = connection.BeginTransaction();
try
{
    // Multiple insert, update, or delete operations
    transaction.Commit();
}
catch
{
    transaction.Rollback();
}

var transaction = connection.BeginTransaction();
try
{
    // Multiple insert, update, or delete operations
    transaction.Commit();
}
catch
{
    transaction.Rollback();
}

Dim transaction = connection.BeginTransaction()
Try
	' Multiple insert, update, or delete operations
	transaction.Commit()
Catch
	transaction.Rollback()
End Try

Objekt-Relationales Mapping (ORM) mit Entity Framework

Entity Framework(EF) ist ein weit verbreitetes ORM-Tool im .NET-Ökosystem. Es vereinfacht die Datenbankprogrammierung, indem es Entwicklern ermöglicht, mit relationalen Daten unter Verwendung domänenspezifischer Objekte zu arbeiten. Hier erfahren Sie, wie Sie Entity Framework mit SQLite verwenden können.

1. Installation von Entity Framework

Stellen Sie zunächst sicher, dass Sie das für SQLite spezifische Entity Framework NuGet-Paket installiert haben:

1. Öffnen Sie den NuGet-Paketmanager in Visual Studio.

2. Suchen Sie nach "Entity Framework SQLite" und installieren Sie es.

2. Entitätsklassen erstellen

Entitätsklassen sind Darstellungen von Datenbanktabellen. Sie können für jede Tabelle, mit der Sie interagieren wollen, eine Klasse erstellen.

public class Person
{
    public int Id { get; set; } // Primary Key
    public string Name { get; set; }
}

public class Person
{
    public int Id { get; set; } // Primary Key
    public string Name { get; set; }
}

Public Class Person
	Public Property Id() As Integer ' -  Primary Key
	Public Property Name() As String
End Class

3. DbContext

Sie müssen eine Klasse erstellen, die von "DbContext" erbt. Diese Klasse stellt die Sitzung mit der Datenbank dar und ermöglicht es Ihnen, Instanzen der Entitäten abzufragen und zu speichern.

public class MyDbContext : DbContext
{
    public DbSet<Person> Persons { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite("Data Source=mydatabase.db;");
    }
}

public class MyDbContext : DbContext
{
    public DbSet<Person> Persons { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite("Data Source=mydatabase.db;");
    }
}

Public Class MyDbContext
	Inherits DbContext

	Public Property Persons() As DbSet(Of Person)

	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		optionsBuilder.UseSqlite("Data Source=mydatabase.db;")
	End Sub
End Class

4. CRUD-Vorgänge

Entity Framework vereinfacht das Erstellen, Lesen, Aktualisieren und Löschen(CRUD) operationen. So können Sie einen neuen Datensatz einfügen:

using (var db = new MyDbContext())
{
    db.Persons.Add(new Person { Name = "John" });
    db.SaveChanges();
}

using (var db = new MyDbContext())
{
    db.Persons.Add(new Person { Name = "John" });
    db.SaveChanges();
}

Using db = New MyDbContext()
	db.Persons.Add(New Person With {.Name = "John"})
	db.SaveChanges()
End Using

Das Lesen, Aktualisieren und Löschen von Datensätzen ist mit Entity Framework ähnlich rationalisiert und unkompliziert, was einen prägnanten und wartbaren Code ermöglicht.

Arbeiten mit XML-Dateien und anderen Datenanbietern

SQLite ist nicht auf relationale Daten beschränkt; es bietet auch Flexibilität bei der Verarbeitung anderer Datentypen, einschließlich XML-Dateien.

1. Speichern von XML-Daten

Sie können XML-Daten in einer SQLite-Datenbank speichern. Dies kann nützlich sein, wenn Sie mit Konfigurationsdaten oder anderen hierarchischen Strukturen arbeiten.

string xmlData = "<person><name>John</name></person>";
string query = "INSERT INTO xmltable (data) VALUES (@data)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@data", xmlData);
command.ExecuteNonQuery();

string xmlData = "<person><name>John</name></person>";
string query = "INSERT INTO xmltable (data) VALUES (@data)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@data", xmlData);
command.ExecuteNonQuery();

Dim xmlData As String = "<person><name>John</name></person>"
Dim query As String = "INSERT INTO xmltable (data) VALUES (@data)"
Dim command = New SQLiteCommand(query, connection)
command.Parameters.AddWithValue("@data", xmlData)
command.ExecuteNonQuery()

Abrufen von XML-Daten

Sie können XML-Daten mithilfe von Standard-XML-Parsing-Techniken in C# abrufen und bearbeiten.

string query = "SELECT data FROM xmltable WHERE id = 1";
var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();
string xmlData = reader ["data"].ToString();

// Parse the XML data as needed

string query = "SELECT data FROM xmltable WHERE id = 1";
var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();
string xmlData = reader ["data"].ToString();

// Parse the XML data as needed

Dim query As String = "SELECT data FROM xmltable WHERE id = 1"
Dim command = New SQLiteCommand(query, connection)
Dim reader = command.ExecuteReader()
Dim xmlData As String = reader ("data").ToString()

' Parse the XML data as needed

Zusammenarbeit mit anderen Datenanbietern

SQLite lässt sich auch gut mit verschiedenen Datenanbietern integrieren und ermöglicht so Interoperabilität und Flexibilität. Das bedeutet, dass Sie nahtlos zwischen verschiedenen Datenbanken wechseln oder sogar verschiedene Datenquellen innerhalb einer einzigen Anwendung kombinieren können.

Einführung in den Iron Suit: Ein leistungsfähiges Set von Bibliotheken

Nachdem wir die Bereiche SQLite und logische Operatoren in C# erkundet haben, ist es nun an der Zeit, eine bemerkenswerte Sammlung von Tools vorzustellen, die die Entwicklungserfahrung in der .NET-Umgebung ergänzen und verbessern. Die Iron Suite ist eine Sammlung leistungsstarker Bibliotheken, bestehend aus IronPDF, IronXL, IronOCR und IronBarcode, die jeweils unterschiedlichen Zwecken dienen.

IronPDF: C# PDF-Bibliothek

Umfassender Leitfaden zu IronPDF ist eine umfassende Bibliothek zum Erstellen, Lesen und Verarbeiten von PDF-Dateien in C#. Egal, ob Sie Berichte, Rechnungen oder andere Dokumente im PDF-Format erstellen müssen, IronPDF hat alles für Sie. Eine einzigartige Funktion von IronPDF ist die Möglichkeit, HTML in PDF zu konvertieren. Sie können HTML als PDF-Dokument rendern, einschließlich CSS, JavaScript und Bilder, was es zu einem mächtigen Werkzeug macht. Sehen Sie sich dieses Tutorial anKonvertierung von HTML in PDF mit IronPDF für eine Schritt-für-Schritt-Anleitung.

IronPDF'sHTML zu PDF Funktion der wichtigste Aspekt der Übersetzung ist die Beibehaltung aller Layouts und Stile. Es erzeugt PDFs aus Webinhalten, ideal für Berichte, Rechnungen und Dokumentationen. Sie können HTML-Dateien, URLs und HTML-Strings nahtlos in PDFs konvertieren.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

IronPDF kann bei der Arbeit mit SQLite-Datenbanken ein unverzichtbares Werkzeug sein. Sie können aus Ihren SQLite-Datenbankdaten PDF-Berichte erstellen, die eine nahtlose Präsentation und gemeinsame Nutzung der Daten ermöglichen.

IronXL: Excel-Dateiverwaltung leicht gemacht

Erkunden SieIronXL für Excel-Integration die es Entwicklern ermöglicht, Excel-Dateien mühelos zu lesen, zu schreiben und zu manipulieren. Es ist kompatibel mit XLS, XLSX und anderen Formaten und damit ein ideales Werkzeug für die Bearbeitung von Tabellenkalkulationsdaten. Sie können Excel-Dateien lesen, bearbeiten und sogar ganz neue Dateien erstellen. Die Funktionalität von IronXL lässt sich gut in die Datenbankverwaltung integrieren, einschließlich SQLite, um Daten zu exportieren und zu importieren.

IronOCR: Optische Zeichenerkennung in C#

MitIronOCR für Texterkennungist das Scannen von Text aus Bildern und PDF-Dateien ein Kinderspiel. Es ist eine vielseitige OCR(Optische Zeichenerkennung) bibliothek zur Erkennung von Text aus verschiedenen Quellen.

Stellen Sie sich vor, Sie speichern gescannte Dokumente in einer SQLite-Datenbank und verwenden IronOCR, um den Text in diesen Dokumenten abzurufen und zu erkennen. Die Möglichkeiten sind endlos und bieten leistungsstarke Textabrufe und Suchfunktionen.

IronBarcode: Die ultimative Bibliothek zum Erzeugen und Lesen von Barcodes

Barcode-Erstellung und -Lesung sind einfach mitLeistungsstarke Barcode-Integration über IronBarcode. Es unterstützt mehrere Barcode-Formate und bietet eine robuste API für alle Barcode-bezogenen Anforderungen. IronBarcode kann eine wesentliche Rolle in Anwendungen spielen, die SQLite verwenden, wo Barcodes Produkte oder andere Dateneinheiten darstellen können. Das Speichern und Abrufen von Strichcodes in der SQLite-Datenbank verbessert die Datenintegrität und erleichtert den schnellen Zugriff.

Schlussfolgerung

SQLite ist eine leistungsstarke und dennoch leichtgewichtige Datenbank-Engine, die sich für Anfänger und Profis gleichermaßen eignet. Von der Erstellung von Tabellen und dem Einfügen von Zeilen bis hin zur Verwaltung von Transaktionen und dem Schutz vor SQL-Injection-Angriffen bietet SQLite viele Funktionen. Egal, ob Sie eine Konsolen- oder mobile Anwendung erstellen oder mit Fremdschlüsseln und Datensätzen arbeiten müssen, SQLite ist eine ausgezeichnete Wahl.

Die Iron Suite, bestehend aus IronPDF, IronXL, IronOCR und IronBarcode, ist eine Fundgrube von Tools, die die Möglichkeiten Ihrer C#-Entwicklungsprojekte erweitern, egal ob Sie mit SQLite-Datenbanken oder anderen Domänen arbeiten.

Noch reizvoller ist, dass jedes dieser Produkte Folgendes bieteteine kostenlose Testversion für Iron Software Produkteso haben Sie ausreichend Zeit, die zahlreichen Funktionen zu erkunden und zu verstehen. Wenn Sie sich entscheiden, mit diesen Tools weiterzumachen, beginnt die Lizenzierung bei $749 pro Produkt. Sie können auch das komplette Iron Suit-Paket zum Preis von nur zwei Einzelprodukten erwerben.