.NET HILFE

Sqlite C# .NET (Wie es für Entwickler funktioniert)

Aktualisiert:Juni 22, 2025

SQLite ist eine beliebte, leichte und eigenständige relationale Datenbank-Engine, die in verschiedenen Datenzugriffsanwendungen und Plattformumgebungen weit verbreitet ist. Im Kontext der .NET-Entwicklung dient der SQLite-Quellcode als ausgezeichnete Wahl, um eine zuverlässige Datenbanklösung in Ihre Systemanwendungen zu integrieren. Dieser Artikel wird in die Welt der SQLite-Transaktionen eintauchen, seine Funktionen, Vorteile und die effektive Nutzung in Ihren .NET-Projekten erkunden.

Benutzung von SQLite in C#35;

SQLite-Bibliothek herunterladen
Eine Datenbank erstellen und Daten einfügen
Mit Reader lesen
SQLite mit Entity Framework und LINQ-Abfragemethode verwenden
PDF-Bericht mit IronPDF erstellen

Was ist SQLite?

SQLite ist eine beliebte Open-Source-Datenbank-Engine, die in Anwendungen eingebettet werden kann, ohne dass eine separate Serverkomponente erforderlich ist. Es ist schnell, zuverlässig und plattformübergreifend. SQLite kann mit .NET-Projektanwendungen über verschiedene Bibliotheken verwendet werden, die ADO.NET-Schnittstellen bereitstellen. Eine dieser Bibliotheken ist Microsoft.Data.SQLite. Dies erlaubt es Ihnen, SQLite als Datenquelle für Ihre .NET-Anwendungen zu verwenden, egal ob es sich um Konsole-, Desktop-, Web- oder Mobile-Anwendungen handelt. Sie können auch Entity Framework Core verwenden, um Objekt-Relation-Mapper zu verwenden und Ihre SQLite-Datenbank mit LINQ zu durchsuchen.

Dieser Artikel zeigt Ihnen, wie Sie Microsoft.Data.Sqlite verwenden, um eine SQLite-Datenbank in einer .NET-Konsolenanwendung zu entwickeln, zu verbinden und zu manipulieren. Sie werden lernen wie man:

Installieren Sie das Microsoft.Data.Sqlite NuGet-Paket
Erstellen Sie eine SQLite-Verbindung und führen Sie SQL-Befehle aus
Erstellen und füllen Sie Tabellen mithilfe von Datenlesern und Parametern
Abfragen von Daten mit Datenlesern
Implementieren Sie EntityFramework Core
Abfragen von Daten mit LINQ
PDF-Bericht generiert

Installation der SQLite-Bibliothek

Um Microsoft.Data.Sqlite zu verwenden, müssen Sie das NuGet-Paket installieren, das die Bibliothek und ihre Abhängigkeiten enthält. Sie können das mittels des Visual Studio-Paket-Managers, der .NET Core CLI oder eines anderen Werkzeugs, das NuGet unterstützt, tun. Dieser Artikel verwendet den Paket-Manager, um eine Konsolenanwendung zu erstellen und Microsoft.Data.Sqlite zu installieren. Dazu öffnen Sie eine Paket-Manager-Konsole und führen die folgenden Befehle aus:

Install-Package Microsoft.Data.Sqlite

Der obige Befehl wird das Paket wie unten gezeigt installieren.

Erstellen einer SQLite-Datenbank

Um mit einer SQLite-Datenbank zu arbeiten, müssen Sie ein SqliteConnection-Objekt erstellen, das die Verbindung zur Datenbankdatei darstellt. Sie können den Dateinamen und andere Optionen in der Verbindungszeichenfolge angeben. Falls die Datei nicht existiert, wird sie automatisch erstellt. Zum Beispiel erstellt das unten stehende Programm eine Verbindung zu einer Datenbankdatei namens employee.db im aktuellen Verzeichnis:

using (var connection = new SqliteConnection("Data Source=employee.db"))
{
    connection.Open();
    // ...
}

using (var connection = new SqliteConnection("Data Source=employee.db"))
{
    connection.Open();
    // ...
}

Using connection = New SqliteConnection("Data Source=employee.db")
	connection.Open()
	' ...
End Using

$vbLabelText $csharpLabel

Die using-Anweisung stellt sicher, dass die Verbindung geschlossen und entsorgt wird, wenn sie außerhalb des Gültigkeitsbereichs gelangt. Um SQL-Befehle auszuführen, müssen Sie ein SqlCommand-Objekt erstellen und es mit der Verbindung verknüpfen. Sie können die CommandText-Eigenschaft auf die auszuführende SQL-Anweisung setzen und optional Parameter zur Parameters-Sammlung hinzufügen. Sie können dann eine der Methoden des SqlCommand-Objekts aufrufen, um den Befehl auszuführen, wie zum Beispiel ExecuteNonQuery, ExecuteScalar oder ExecuteReader.

Tabelle in SQLite erstellen

Der folgende Code erstellt eine Tabelle namens Employee mithilfe der ExecuteNonQuery-Methode:

using (var connection = new SqliteConnection("Data Source=employee.db"))
{
    connection.Open();
    var command = connection.CreateCommand();
    command.CommandText = @"CREATE TABLE Employee (
        Id INTEGER PRIMARY KEY,
        FirstName TEXT NOT NULL,
        LastName TEXT NOT NULL,
        Designation TEXT NOT NULL )";
    command.ExecuteNonQuery();
}

using (var connection = new SqliteConnection("Data Source=employee.db"))
{
    connection.Open();
    var command = connection.CreateCommand();
    command.CommandText = @"CREATE TABLE Employee (
        Id INTEGER PRIMARY KEY,
        FirstName TEXT NOT NULL,
        LastName TEXT NOT NULL,
        Designation TEXT NOT NULL )";
    command.ExecuteNonQuery();
}

Using connection = New SqliteConnection("Data Source=employee.db")
	connection.Open()
	Dim command = connection.CreateCommand()
	command.CommandText = "CREATE TABLE Employee (
        Id INTEGER PRIMARY KEY,
        FirstName TEXT NOT NULL,
        LastName TEXT NOT NULL,
        Designation TEXT NOT NULL )"
	command.ExecuteNonQuery()
End Using

$vbLabelText $csharpLabel

Daten in eine Tabelle einfügen

Um Daten in eine Tabelle einzufügen, können Sie dasselbe SqlCommand-Objekt verwenden und die CommandText-Eigenschaft auf eine INSERT-Anweisung setzen. Zum Beispiel fügt der folgende Code drei Zeilen in die Employee-Tabelle ein.

using (var connection = new SqliteConnection("Data Source=employee.db"))
{
    var command = connection.CreateCommand();
    StringBuilder builder = new StringBuilder();
    builder.Append("INSERT INTO Employee VALUES(1, 'John', 'Sami', 'CEO');");
    builder.Append("INSERT INTO Employee VALUES(2, 'David', 'Watson', 'Software Engineer');");
    builder.Append("INSERT INTO Employee VALUES(3, 'Victor', 'Khan', 'Content Writer');");
    connection.Open();
    command.CommandText = builder.ToString();
    command.ExecuteNonQuery();
}

using (var connection = new SqliteConnection("Data Source=employee.db"))
{
    var command = connection.CreateCommand();
    StringBuilder builder = new StringBuilder();
    builder.Append("INSERT INTO Employee VALUES(1, 'John', 'Sami', 'CEO');");
    builder.Append("INSERT INTO Employee VALUES(2, 'David', 'Watson', 'Software Engineer');");
    builder.Append("INSERT INTO Employee VALUES(3, 'Victor', 'Khan', 'Content Writer');");
    connection.Open();
    command.CommandText = builder.ToString();
    command.ExecuteNonQuery();
}

Using connection = New SqliteConnection("Data Source=employee.db")
	Dim command = connection.CreateCommand()
	Dim builder As New StringBuilder()
	builder.Append("INSERT INTO Employee VALUES(1, 'John', 'Sami', 'CEO');")
	builder.Append("INSERT INTO Employee VALUES(2, 'David', 'Watson', 'Software Engineer');")
	builder.Append("INSERT INTO Employee VALUES(3, 'Victor', 'Khan', 'Content Writer');")
	connection.Open()
	command.CommandText = builder.ToString()
	command.ExecuteNonQuery()
End Using

$vbLabelText $csharpLabel

Lesen von Daten aus SQLite

Um Daten aus einer Tabelle zu lesen, können Sie die ExecuteReader-Methode des SqlCommand-Objekts verwenden und die CommandText-Eigenschaft auf eine SELECT-Anweisung setzen. Dies wird ein SqliteDataReader-Objekt zurückgeben, mit dem Sie über die Zeilen iterieren und auf die Werte per Spaltenname oder Index zugreifen können. Sie können die Read-Methode verwenden, um zur nächsten Zeile zu gelangen, und die GetXXX-Methoden, um die Werte als den entsprechenden Datentyp zu erhalten. Zum Beispiel liest der folgende Code alle Zeilen aus der Employee-Tabelle und gibt sie auf der Konsole aus:

using (var connection = new SqliteConnection("Data Source=employee.db"))
{
    var command = connection.CreateCommand();
    command.CommandText = @"SELECT * FROM Employee";
    connection.Open();
    using (var reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            var id = reader.GetInt32(0);
            string firstName = reader.GetString(1);
            string lastName = reader.GetString(2);
            string designation = reader.GetString(3);
            Console.WriteLine($"{id}: {firstName} - {lastName} - {designation}");
        }
    }
}

using (var connection = new SqliteConnection("Data Source=employee.db"))
{
    var command = connection.CreateCommand();
    command.CommandText = @"SELECT * FROM Employee";
    connection.Open();
    using (var reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            var id = reader.GetInt32(0);
            string firstName = reader.GetString(1);
            string lastName = reader.GetString(2);
            string designation = reader.GetString(3);
            Console.WriteLine($"{id}: {firstName} - {lastName} - {designation}");
        }
    }
}

Using connection = New SqliteConnection("Data Source=employee.db")
	Dim command = connection.CreateCommand()
	command.CommandText = "SELECT * FROM Employee"
	connection.Open()
	Using reader = command.ExecuteReader()
		Do While reader.Read()
			Dim id = reader.GetInt32(0)
			Dim firstName As String = reader.GetString(1)
			Dim lastName As String = reader.GetString(2)
			Dim designation As String = reader.GetString(3)
			Console.WriteLine($"{id}: {firstName} - {lastName} - {designation}")
		Loop
	End Using
End Using

$vbLabelText $csharpLabel

Ausgabe

Die Ausgabe dieses Codes ist:

Sqlite C# .NET (How It Works For Developer): Abbildung 1 - Ausgabe

Abfrage von Daten

Wenn Sie es vorziehen, LINQ zu verwenden, um Ihre SQLite-Datenbank abzufragen, können Sie Entity Framework Core verwenden, um Ihre Tabellen zu Klassen abzubilden und Abfragen mit LINQ-Ausdrücken durchzuführen. Dazu müssen Sie das Microsoft.EntityFrameworkCore.Sqlite-Paket installieren, das vom Microsoft.Data.Sqlite-Paket abhängt. Sie müssen auch eine Klasse erstellen, die von DbContext erbt und den Datenbankkontext darstellt. Diese Klasse muss einen Konstruktor haben, der einen DbContextOptions-Parameter akzeptiert und diesen an den Basiskonstruktor weitergibt. Sie muss auch eine DbSet-Eigenschaft für jede Tabelle haben, die Sie in eine Klasse abbilden möchten. Zum Beispiel definiert der folgende Code eine Stock-Klasse und eine DatabaseContext-Klasse:

using Microsoft.EntityFrameworkCore;
public class Stock
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Symbol { get; set; } = string.Empty;
    public double Price { get; set; }
}
public class DatabaseContext : DbContext
{
    public DatabaseContext(DbContextOptions options) : base(options) { }
    public DbSet<Stock> Stock { get; set; }
}

using Microsoft.EntityFrameworkCore;
public class Stock
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Symbol { get; set; } = string.Empty;
    public double Price { get; set; }
}
public class DatabaseContext : DbContext
{
    public DatabaseContext(DbContextOptions options) : base(options) { }
    public DbSet<Stock> Stock { get; set; }
}

Imports Microsoft.EntityFrameworkCore
Public Class Stock
	Public Property Id() As Integer
	Public Property Name() As String = String.Empty
	Public Property Symbol() As String = String.Empty
	Public Property Price() As Double
End Class
Public Class DatabaseContext
	Inherits DbContext

	Public Sub New(ByVal options As DbContextOptions)
		MyBase.New(options)
	End Sub
	Public Property Stock() As DbSet(Of Stock)
End Class

$vbLabelText $csharpLabel

Um den Datenbankkontext zu erstellen, müssen Sie die DbContextOptionsBuilder-Klasse verwenden und die Verbindungszeichenfolge und den Datenbankanbieter angeben. Sie können auch die Database.EnsureCreated-Methode verwenden, um die Datenbank und die Tabellen zu erstellen, wenn sie nicht existieren. Zum Beispiel erstellt der folgende Code den Datenbankkontext und die Datenbank:

var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseSqlite("Data Source=stock.db");
using (var context = new DatabaseContext(optionsBuilder.Options))
{
    context.Database.EnsureCreated();
}

var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseSqlite("Data Source=stock.db");
using (var context = new DatabaseContext(optionsBuilder.Options))
{
    context.Database.EnsureCreated();
}

Dim optionsBuilder = New DbContextOptionsBuilder(Of DatabaseContext)()
optionsBuilder.UseSqlite("Data Source=stock.db")
Using context = New DatabaseContext(optionsBuilder.Options)
	context.Database.EnsureCreated()
End Using

$vbLabelText $csharpLabel

Um Daten in die Datenbank einzufügen, können Sie die Add oder AddRange-Methoden der DbSet-Eigenschaft verwenden und die Objekte übergeben, die Sie einfügen möchten. Sie können auch die SaveChanges-Methode verwenden, um die Änderungen in der Datenbank zu speichern. Zum Beispiel fügt der folgende Code drei Stocks in die Datenbank ein:

static void Main(string[] args)
{
    var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
    optionsBuilder.UseSqlite("Data Source=stock.db");
    using (var context = new DatabaseContext(optionsBuilder.Options))
    {
        context.Database.EnsureCreated();
        var stock = new List<Stock> {
            new Stock { Id = 1, Name = "NCR", Symbol = "$$", Price = 5.6 },
            new Stock { Id = 2, Name = "Google", Symbol = "GG", Price = 10.6 },
            new Stock { Id = 3, Name = "Apple", Symbol = "AA", Price = 3.6 }
        };
        context.AddRange(stock);
        context.SaveChanges();
    }
}

static void Main(string[] args)
{
    var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
    optionsBuilder.UseSqlite("Data Source=stock.db");
    using (var context = new DatabaseContext(optionsBuilder.Options))
    {
        context.Database.EnsureCreated();
        var stock = new List<Stock> {
            new Stock { Id = 1, Name = "NCR", Symbol = "$$", Price = 5.6 },
            new Stock { Id = 2, Name = "Google", Symbol = "GG", Price = 10.6 },
            new Stock { Id = 3, Name = "Apple", Symbol = "AA", Price = 3.6 }
        };
        context.AddRange(stock);
        context.SaveChanges();
    }
}

Shared Sub Main(ByVal args() As String)
	Dim optionsBuilder = New DbContextOptionsBuilder(Of DatabaseContext)()
	optionsBuilder.UseSqlite("Data Source=stock.db")
	Using context = New DatabaseContext(optionsBuilder.Options)
		context.Database.EnsureCreated()
		Dim stock As New List(Of Stock) From {
			New Stock With {
				.Id = 1,
				.Name = "NCR",
				.Symbol = "$$",
				.Price = 5.6
			},
			New Stock With {
				.Id = 2,
				.Name = "Google",
				.Symbol = "GG",
				.Price = 10.6
			},
			New Stock With {
				.Id = 3,
				.Name = "Apple",
				.Symbol = "AA",
				.Price = 3.6
			}
		}
		context.AddRange(stock)
		context.SaveChanges()
	End Using
End Sub

$vbLabelText $csharpLabel

Um Daten abzufragen, können Sie LINQ-Methoden oder -Ausdrücke auf der DbSet-Eigenschaft verwenden und Filter, Projektionen, Aggregationen und andere Operationen anwenden. Die Abfragen werden in SQL-Anweisungen übersetzt und auf der Datenbank ausgeführt. Zum Beispiel fragt der folgende Code die Stocks ab, deren Preis unter sechs Dollar liegt, und gibt ihre Namen aus:

using (var context = new DatabaseContext(optionsBuilder.Options))
{
    var cheapStocks = context.Stock.Where(p => p.Price < 6).Select(p => p.Name);
    Console.WriteLine("Stock Less than $6 are:");
    foreach (string stock in cheapStocks)
    {
        Console.WriteLine(stock);
    }
}

using (var context = new DatabaseContext(optionsBuilder.Options))
{
    var cheapStocks = context.Stock.Where(p => p.Price < 6).Select(p => p.Name);
    Console.WriteLine("Stock Less than $6 are:");
    foreach (string stock in cheapStocks)
    {
        Console.WriteLine(stock);
    }
}

Using context = New DatabaseContext(optionsBuilder.Options)
	Dim cheapStocks = context.Stock.Where(Function(p) p.Price < 6).Select(Function(p) p.Name)
	Console.WriteLine("Stock Less than $6 are:")
	For Each stock As String In cheapStocks
		Console.WriteLine(stock)
	Next stock
End Using

$vbLabelText $csharpLabel

Angenommen, wir haben ein Szenario, in dem wir eine PDF-Datei erstellen müssen, die die Liste der Stocks enthält. Dies können wir problemlos mit IronPDF machen.

Einführung in IronPDF

IronPDF ist eine Bibliothek, die Ihnen hilft, PDF-Dateien in Ihren .NET-Anwendungen zu erstellen, zu bearbeiten und zu lesen, ohne dass mehrere Pakete erforderlich sind. Es kann PDFs aus HTML, URL, JavaScript, CSS und vielen Bildformaten generieren sowie Kopfzeilen, Fußzeilen, Signaturen, Anhänge und Passwörter hinzufügen. Es unterstützt auch die plattformübergreifende Kompatibilität, Multithreading und asynchrone Unterstützung.

IronPDFs HTML-zu-PDF-Funktion ist sein Hauptmerkmal und bewahrt alle Layouts und Styles. Es generiert PDFs aus Webinhalten und ist ideal für Berichte, Rechnungen und Dokumentationen. Sie können HTML-Dateien, URLs und HTML-Strings nahtlos in PDFs umwandeln.

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

$vbLabelText $csharpLabel

IronPDF installieren

Um IronPDF in unser Projekt zu installieren, schreiben Sie den folgenden Befehl in die Paket-Manager-Konsole.

Install-Package IronPdf

Dieser Befehl wird IronPDF zusammen mit all seinen Abhängigkeiten installieren.

Lizenzschlüssel hinzufügen

IronPDF erfordert einen Lizenzschlüssel zur Nutzung. Wir können problemlos einen Testlizenzschlüssel von der IronPDF Testlizenz-Seite erhalten.

Fügen Sie diesen Code zum Start Ihrer Anwendung hinzu, bevor IronPDF verwendet wird. Dieser Ansatz ist universell wirksam und unkompliziert und funktioniert sowohl für .NET Core- als auch für .NET Framework-Anwendungen.

IronPdf.License.LicenseKey = "IRONSUITE.ABC.XYZ.MYCOMPANY.COM.ABC-DEPLOYMENT.TRIAL-P45MXL.TRIAL.EXPIRES.31.JAN.2028";

IronPdf.License.LicenseKey = "IRONSUITE.ABC.XYZ.MYCOMPANY.COM.ABC-DEPLOYMENT.TRIAL-P45MXL.TRIAL.EXPIRES.31.JAN.2028";

IronPdf.License.LicenseKey = "IRONSUITE.ABC.XYZ.MYCOMPANY.COM.ABC-DEPLOYMENT.TRIAL-P45MXL.TRIAL.EXPIRES.31.JAN.2028"

$vbLabelText $csharpLabel

Erstellen einer PDF-Datei mit einer Bestandsliste

Dieser C#-Code erzeugt einen PDF-Bericht aus Bestandsdaten, die in einer SQLite-Datenbank gespeichert sind. Er erstellt dynamisch eine HTML-Tabelle, füllt sie mit Bestandsinformationen und verwendet einen Chrome-basierten PDF-Renderer, um die Tabelle in eine herunterladbare "stock.pdf"-Datei zu konvertieren, was eine effiziente Berichterstattung und Verteilung von Aktieninformationen ermöglicht.

var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseSqlite("Data Source=stock.db");
StringBuilder builder = new StringBuilder();
string style = "<!DOCTYPE html>\r\n<html>\r\n<head>\r\n<style>\r\n#stock {\r\n  font-family: Arial, Helvetica, sans-serif;\r\n  border-collapse: collapse;\r\n  width: 100%;\r\n}\r\n\r\n#stock td, #stock th {\r\n  border: 1px solid #ddd;\r\n  padding: 8px;\r\n}\r\n\r\n#stock tr:nth-child(even){background-color: #f2f2f2;}\r\n\r\n#stock tr:hover {background-color: #ddd;}\r\n\r\n#stock th {\r\n  padding-top: 12px;\r\n  padding-bottom: 12px;\r\n  text-align: left;\r\n  background-color: #04AA6D;\r\n  color: white;\r\n}\r\n</style>\r\n</head>\r\n<body>\r\n\r\n<h1>A Stock Table</h1>";
builder.Append(style);
builder.Append("<table id=\"stock\"><tr><td>Stock Symbol</td><td>Stock Name</td><td>Stock Price</td></tr>");
using (var context = new DatabaseContext(optionsBuilder.Options))
{
    var stocks = context.Stock;
    foreach (Stock stock in stocks)
    {
        builder.Append($"<tr><td>{stock.Symbol}</td><td>{stock.Name}</td><td>{stock.Price}</td></tr>");
    }
}
builder.Append("</table></body></html>");
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(builder.ToString());
pdf.SaveAs("stock.pdf");

var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseSqlite("Data Source=stock.db");
StringBuilder builder = new StringBuilder();
string style = "<!DOCTYPE html>\r\n<html>\r\n<head>\r\n<style>\r\n#stock {\r\n  font-family: Arial, Helvetica, sans-serif;\r\n  border-collapse: collapse;\r\n  width: 100%;\r\n}\r\n\r\n#stock td, #stock th {\r\n  border: 1px solid #ddd;\r\n  padding: 8px;\r\n}\r\n\r\n#stock tr:nth-child(even){background-color: #f2f2f2;}\r\n\r\n#stock tr:hover {background-color: #ddd;}\r\n\r\n#stock th {\r\n  padding-top: 12px;\r\n  padding-bottom: 12px;\r\n  text-align: left;\r\n  background-color: #04AA6D;\r\n  color: white;\r\n}\r\n</style>\r\n</head>\r\n<body>\r\n\r\n<h1>A Stock Table</h1>";
builder.Append(style);
builder.Append("<table id=\"stock\"><tr><td>Stock Symbol</td><td>Stock Name</td><td>Stock Price</td></tr>");
using (var context = new DatabaseContext(optionsBuilder.Options))
{
    var stocks = context.Stock;
    foreach (Stock stock in stocks)
    {
        builder.Append($"<tr><td>{stock.Symbol}</td><td>{stock.Name}</td><td>{stock.Price}</td></tr>");
    }
}
builder.Append("</table></body></html>");
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(builder.ToString());
pdf.SaveAs("stock.pdf");

Imports Microsoft.VisualBasic

Dim optionsBuilder = New DbContextOptionsBuilder(Of DatabaseContext)()
optionsBuilder.UseSqlite("Data Source=stock.db")
Dim builder As New StringBuilder()
Dim style As String = "<!DOCTYPE html>" & vbCrLf & "<html>" & vbCrLf & "<head>" & vbCrLf & "<style>" & vbCrLf & "#stock {" & vbCrLf & "  font-family: Arial, Helvetica, sans-serif;" & vbCrLf & "  border-collapse: collapse;" & vbCrLf & "  width: 100%;" & vbCrLf & "}" & vbCrLf & vbCrLf & "#stock td, #stock th {" & vbCrLf & "  border: 1px solid #ddd;" & vbCrLf & "  padding: 8px;" & vbCrLf & "}" & vbCrLf & vbCrLf & "#stock tr:nth-child(even){background-color: #f2f2f2;}" & vbCrLf & vbCrLf & "#stock tr:hover {background-color: #ddd;}" & vbCrLf & vbCrLf & "#stock th {" & vbCrLf & "  padding-top: 12px;" & vbCrLf & "  padding-bottom: 12px;" & vbCrLf & "  text-align: left;" & vbCrLf & "  background-color: #04AA6D;" & vbCrLf & "  color: white;" & vbCrLf & "}" & vbCrLf & "</style>" & vbCrLf & "</head>" & vbCrLf & "<body>" & vbCrLf & vbCrLf & "<h1>A Stock Table</h1>"
builder.Append(style)
builder.Append("<table id=""stock""><tr><td>Stock Symbol</td><td>Stock Name</td><td>Stock Price</td></tr>")
Using context = New DatabaseContext(optionsBuilder.Options)
	Dim stocks = context.Stock
	For Each stock As Stock In stocks
		builder.Append($"<tr><td>{stock.Symbol}</td><td>{stock.Name}</td><td>{stock.Price}</td></tr>")
	Next stock
End Using
builder.Append("</table></body></html>")
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(builder.ToString())
pdf.SaveAs("stock.pdf")

$vbLabelText $csharpLabel

Der obige C#-Codeabschnitt ist darauf ausgelegt, eine HTML-Tabelle zu erstellen, die Bestandsinformationen aus einer SQLite-Datenbank anzeigt und sie anschließend in eine PDF-Datei konvertiert. Er verwendet die Entity Framework Core-Bibliothek, um mit der Datenbank zu interagieren. Zunächst konfiguriert er einen DbContextOptionsBuilder, um SQLite mit einem bestimmten Verbindungszeichenfolgen zu verwenden. Der Code erstellt dann eine HTML-Zeichenfolge mit eingebetteten CSS-Stilen für das Erscheinungsbild der Tabelle, erstellt eine Tabellenstruktur mit Kopfzeilen, fragt die SQLite-Datenbank nach Bestandsinformationen ab, füllt die HTML-Tabelle mit den abgerufenen Daten und nutzt schließlich einen Chrome-basierten PDF-Renderer, um den HTML-Inhalt in eine PDF-Datei namens "stock.pdf" zu konvertieren. Die resultierende PDF enthält eine Tabelle mit Bestandsinformationen, Namen und Preisen.

Ausgabe ist wie

Sqlite C# .NET (How It Works For Developer): Abbildung 2 - Bestandslistenausgabe

Abschluss

Abschließend bietet die Verwendung von SQLite in .NET für das Datenbankmanagement eine leichte und vielseitige Lösung. Dieser Artikel untersuchte die Integration von SQLite in .NET-Anwendungen und zeigte seine wichtigsten Funktionen und Vorteile. Der bereitgestellte Code zeigte praktische Schritte zur Erstellung, Verbindung und Manipulation einer SQLite-Datenbank in einer .NET-Konsolenanwendung. Zusätzlich hob er die Nutzung von Microsoft.Data.Sqlite und Entity Framework Core für effiziente Datenverwaltung hervor. Die Einbindung von IronPDF veranschaulichte, wie man nahtlos einen PDF-Bericht aus der SQLite-Datenbank generiert, wodurch die Fähigkeiten der Anwendung zur Berichterstattung und Datenverteilung verbessert werden.

IronPDF bietet verschiedene Lizenzoptionen, je nach Anzahl der Entwickler, Standorte, Projekte und Verteilungsbedürfnisse. Die Lizenzen sind unbefristet und beinhalten ein Jahr kostenlosen Support und Updates.

Häufig gestellte Fragen

Was ist SQLite und warum ist es beliebt für .NET-Entwicklung?

SQLite ist eine leichtgewichtige und eigenständige relationale Datenbank-Engine, die in der .NET-Entwicklung aufgrund ihrer Geschwindigkeit, Zuverlässigkeit und plattformübergreifenden Fähigkeiten weit verbreitet ist. Es kann in Anwendungen eingebettet werden, ohne dass eine separate Serverkomponente erforderlich ist.

Wie kann ich SQLite in meine .NET-Anwendung integrieren?

Sie können SQLite in Ihre .NET-Anwendung integrieren, indem Sie das Microsoft.Data.Sqlite NuGet-Paket installieren. Dies bietet ADO.NET-Schnittstellen, mit denen Sie SQLite-Datenbanken in Konsolen-, Desktop-, Web- oder mobilen Anwendungen erstellen, verbinden und manipulieren können.

Wie erstelle und verbinde ich eine SQLite-Datenbank in C#?

Um eine SQLite-Datenbank in C# zu erstellen und zu verbinden, verwenden Sie die SqliteConnection-Klasse, um eine Verbindung herzustellen. Sie können dann SQL-Befehle ausführen, um Tabellen zu erstellen und Daten mit dem SqlCommand-Objekt zu manipulieren.

Kann ich LINQ-Abfragen mit SQLite in .NET verwenden?

Ja, Sie können LINQ-Abfragen mit SQLite in .NET verwenden, indem Sie Entity Framework Core nutzen. Dies ermöglicht objekt-relationale Abbildungen und erlaubt Ihnen, LINQ-Abfragen auf DbSet-Eigenschaften innerhalb einer DbContext-Klasse auszuführen.

Wie kann ich PDF-Berichte aus Daten einer SQLite-Datenbank generieren?

Sie können PDF-Berichte aus SQLite-Datenbankdaten mit IronPDF erstellen. Indem Sie HTML-Darstellungen Ihrer Daten konvertieren oder direkt die Datenbankinhalte verwenden, können Sie detaillierte PDF-Berichte erstellen und mit den Renderfähigkeiten von IronPDF exportieren.

Wie behebe ich häufige SQLite-Probleme in .NET-Anwendungen?

Häufige SQLite-Probleme in .NET-Anwendungen können behoben werden, indem eine ordnungsgemäße Installation des Microsoft.Data.Sqlite-Pakets sichergestellt wird, die SQL-Syntax überprüft wird und Verbindungszeichenfolgen verifiziert werden. Debugging-Tools und Protokolle können ebenfalls helfen, Fehler zu erkennen und zu beheben.

Wie installiere und verwende ich eine PDF-Bibliothek in einem .NET-Projekt?

Um eine PDF-Bibliothek wie IronPDF in einem .NET-Projekt zu installieren, führen Sie Install-Package IronPdf in der Paket-Manager-Konsole aus. Nach der Installation ermöglicht IronPDF das Erstellen, Bearbeiten und Lesen von PDF-Dateien, indem Sie seine umfangreiche API nutzen.

Welche Vorteile bietet die Verwendung von SQLite mit .NET?

Die Verwendung von SQLite mit .NET bietet Vorteile wie Einfachheit, keine Notwendigkeit für einen separaten Server, plattformübergreifende Unterstützung und zuverlässige Leistung. Es ist ideal für leichtgewichtige Anwendungen und kann leicht mit Bibliotheken wie Microsoft.Data.Sqlite integriert werden.

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Kunden-Highlight:

Entwickler im Rampenlicht:

Webinare:

Sqlite C# .NET (Wie es für Entwickler funktioniert)

Benutzung von SQLite in C#35;

Was ist SQLite?

Installation der SQLite-Bibliothek

Erstellen einer SQLite-Datenbank

Tabelle in SQLite erstellen

Daten in eine Tabelle einfügen

Lesen von Daten aus SQLite

Ausgabe

Abfrage von Daten

Einführung in IronPDF

IronPDF installieren

Lizenzschlüssel hinzufügen

Erstellen einer PDF-Datei mit einer Bestandsliste

Ausgabe ist wie

Abschluss

Häufig gestellte Fragen

Was ist SQLite und warum ist es beliebt für .NET-Entwicklung?

Wie kann ich SQLite in meine .NET-Anwendung integrieren?

Wie erstelle und verbinde ich eine SQLite-Datenbank in C#?

Kann ich LINQ-Abfragen mit SQLite in .NET verwenden?

Wie kann ich PDF-Berichte aus Daten einer SQLite-Datenbank generieren?

Wie behebe ich häufige SQLite-Probleme in .NET-Anwendungen?

Wie installiere und verwende ich eine PDF-Bibliothek in einem .NET-Projekt?

Welche Vorteile bietet die Verwendung von SQLite mit .NET?

Sqlite C# .NET (Wie es für Entwickler funktioniert)

Benutzung von SQLite in C#35;

Was ist SQLite?

Installation der SQLite-Bibliothek

Erstellen einer SQLite-Datenbank

Tabelle in SQLite erstellen

Daten in eine Tabelle einfügen

Lesen von Daten aus SQLite

Ausgabe

Abfrage von Daten

Einführung in IronPDF

IronPDF installieren

Lizenzschlüssel hinzufügen

Erstellen einer PDF-Datei mit einer Bestandsliste

Ausgabe ist wie

Abschluss

Häufig gestellte Fragen

Was ist SQLite und warum ist es beliebt für .NET-Entwicklung?

Wie kann ich SQLite in meine .NET-Anwendung integrieren?

Wie erstelle und verbinde ich eine SQLite-Datenbank in C#?

Kann ich LINQ-Abfragen mit SQLite in .NET verwenden?

Wie kann ich PDF-Berichte aus Daten einer SQLite-Datenbank generieren?

Wie behebe ich häufige SQLite-Probleme in .NET-Anwendungen?

Wie installiere und verwende ich eine PDF-Bibliothek in einem .NET-Projekt?

Welche Vorteile bietet die Verwendung von SQLite mit .NET?

Verwandte Artikel

Brückenschlag zwischen einfacher CLI und .NET: Curl DotNet mit IronPDF

RandomNumberGenerator C#

C# String Equals (Wie es für Entwickler funktioniert)

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Trusted by Over 2 Million Engineers Worldwide