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

SQLite ist eine beliebte, leichtgewichtige und in sich geschlossene relationale Datenbank-Engine, die in verschiedenen Datenzugriffsanwendungen und Umgebungsplattformen weit verbreitet ist. Im Rahmen der .NET-Entwicklung ist der SQLite-Quellcode eine ausgezeichnete Wahl für die Integration einer zuverlässigen Datenbanklösungssteuerung in Ihre Systemanwendungen. Dieser Artikel wird in die Welt der SQLite-Transaktionen eintauchen, seine Funktionen und Vorteile untersuchen und zeigen, wie Sie es in Ihren .NET-Projekten effektiv einsetzen können.

Wie man SQLite in C# verwendet;

1. SQLite-Bibliothek herunterladen

2. Erstellen Sie eine Datenbank und fügen Sie die Daten ein

3. Lesen mit Lesegerät

4. Verwendung von SQLite mit Entity Framework und LINQ-Abfrageverfahren

5. PDF-Bericht generieren mit IronPDF

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 über verschiedene Bibliotheken, die ADO.NET-Schnittstellen bereitstellen, mit .NET-Projektanwendungen verwendet werden. Eine dieser Bibliotheken ist Microsoft.Data.SQLite. Damit können Sie SQLite als Datenquelle für Ihre .NET-Anwendungen verwenden, unabhängig davon, ob es sich um Konsolen-, Desktop-, Web- oder mobile Anwendungen handelt. Sie können auch Entity Framework Core verwenden, um ein objektrelationales Mapping durchzuführen und Ihre SQLite-Datenbank mit LINQ abzufragen.

Dieser Artikel zeigt Ihnen, wie Sie Microsoft.Data.Sqlite verwenden, um ein SQLite 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 einer SQLite-Verbindung und Ausführen von SQL-Befehlen
• Tabellen mithilfe von Datenlesern und Parametern erstellen und auffüllen
• Abfrage von Daten mit Datenlesern
• EntityFramework Core implementieren
• Abfrage von Daten mit LINQ
• PDF-Bericht generieren

Installieren 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 dies mit dem Visual Studio Package Manager, der .NET Core CLI oder einem anderen Tool, das NuGet unterstützt, tun. In diesem Artikel wird der Package Manager verwendet, um eine Konsolenanwendung zu erstellen und Microsoft.Data.Sqlite zu installieren. Öffnen Sie dazu eine Paketmanager-Konsole und führen Sie die folgenden Befehle aus:

Install-Package Microsoft.Data.Sqlite

Mit dem obigen Befehl wird das Paket wie unten gezeigt installiert.

SQLite-Datenbank erstellen

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 Verbindung angeben. Wenn die Datei nicht existiert, wird sie automatisch erstellt. Das folgende Programm erstellt zum Beispiel 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

Die using-Anweisung stellt sicher, dass die Verbindung geschlossen und entsorgt wird, wenn sie den Anwendungsbereich verlässt. Um SQL-Befehle auszuführen, müssen Sie ein SQLiteCommand-Objekt erstellen und es mit der Verbindung verknüpfen. Sie können die Eigenschaft CommandText auf die auszuführende SQL-Anweisung setzen und optional Parameter zur Parametersammlung hinzufügen. Sie können dann eine der Methoden des SQLiteCommand-Objekts aufrufen, um den Befehl auszuführen, z. B. ExecuteNonQuery, ExecuteScalar oder ExecuteReader.

Tabelle in SQLite erstellen

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

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

Daten in eine Tabelle einfügen

Um Daten in eine Tabelle einzufügen, können Sie das gleiche SQLiteCommand-Objekt verwenden und die Eigenschaft CommandText auf eine INSERT-Anweisung setzen. Der folgende Code fügt zum Beispiel drei Zeilen in die Tabelle Employee 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

Daten aus SQLite lesen

Um Daten aus einer Tabelle zu lesen, können Sie die Methode ExecuteReader des SQLiteCommand-Objekts verwenden und die Eigenschaft CommandText auf eine SELECT-Anweisung setzen. Dies gibt ein SQLiteDataReader-Objekt zurück, mit dem Sie über die Zeilen iterieren und auf die Werte nach Spaltennamen oder Index zugreifen können. Sie können die Read-Methode verwenden, um zur nächsten Zeile zu gelangen, und die GetXXX-Methode, um die Werte als den entsprechenden Datentyp zu erhalten. Der folgende Code liest zum Beispiel alle Zeilen aus der Tabelle Employee 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).ToString();
            string designation = reader.GetString(3).ToString();
            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).ToString();
            string designation = reader.GetString(3).ToString();
            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).ToString()
			Dim designation As String = reader.GetString(3).ToString()
			Console.WriteLine($"{id}: {firstName} - {lastName} - {designation}")
		Loop
	End Using
End Using

Ausgabe

Die Ausgabe dieses Codes ist:

Abfrage von Daten

Wenn Sie es vorziehen, LINQ zur Abfrage Ihrer SQLite-Datenbank zu verwenden, können Sie Entity Framework Core verwenden, um Ihre Tabellen auf Klassen abzubilden und Abfragen mit LINQ-Ausdrücken durchzuführen. Dazu müssen Sie das Paket Microsoft.EntityFrameworkCore.Sqlite installieren, das vom Paket Microsoft.Data.Sqlite 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 ihn an den Basiskonstruktor weitergibt. Sie muss auch eine DbSet-Eigenschaft für jede Tabelle haben, die Sie einer Klasse zuordnen möchten. Der folgende Code definiert zum Beispiel 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

Um den Datenbankkontext zu erstellen, müssen Sie die Klasse DbContextOptionsBuilder verwenden und die Verbindungszeichenfolge und den Datenbankanbieter angeben. Sie können auch die Methode Database.EnsureCreated verwenden, um die Datenbank und die Tabellen zu erstellen, wenn sie nicht vorhanden sind. Der folgende Code erstellt zum Beispiel 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

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 Methode SaveChanges verwenden, um die Änderungen in der Datenbank zu speichern. Der folgende Code fügt zum Beispiel drei Bestände 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

Um Daten abzufragen, können Sie die LINQ-Methoden oder -Ausdrücke auf die DbSet-Eigenschaft anwenden und Filter, Projektionen, Aggregationen und andere Operationen anwenden. Die Abfragen werden in SQL-Anweisungen übersetzt und in der Datenbank ausgeführt. Der folgende Code fragt z. B. die Aktien ab, deren Preis unter sechs Dollar liegt, und gibt deren 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

Nehmen wir an, wir haben ein Szenario, in dem wir eine PDF-Datei mit einer Liste von Aktien erstellen müssen. Mit IronPDF können wir das ganz einfach tun.

Einführung in IronPDF

IronPDF ist eine Bibliothek, die Ihnen hilft erstellen, bearbeitenund lesen PDF-Dateien in Ihre .NET-Anwendungen einbinden, ohne dass Sie mehrere Pakete benötigen. Es kann PDFs aus HTML, URL, JavaScript, CSS und vielen Bildformaten generieren, ebenso wie kopfzeilen hinzufügen, Fußzeilen, unterschriften, anhängeund passwörter. Außerdem unterstützt es plattformübergreifende Kompatibilität, Multithreading und async-Unterstützung.

IronPDF's HTML zu PDF ist die wichtigste Funktion, die alle Layouts und Stile beibehält. 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 installieren

Um IronPDF in unserem Projekt zu installieren, geben Sie den folgenden Befehl in der Paketmanager-Konsole ein.

Install-Package IronPdf

Mit diesem Befehl wird IronPDF zusammen mit allen Abhängigkeiten installiert.

Lizenzschlüssel hinzufügen

IronPDF erfordert einen Lizenzschlüssel, um es zu benutzen. Wir können einen Testlizenzschlüssel ganz einfach von hier.

Fügen Sie diesen Code in den Start Ihrer Anwendung ein, bevor IronPDF verwendet wird. Dieser Ansatz funktioniert, ist universell wirksam und einfach zu handhaben. Es funktioniert für .NET Core und 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"

PDF-Datei aus Bestandsliste erstellen

Dieser C#-Code erzeugt einen PDF-Bericht aus Bestandsdaten, die in einer SQLite-Datenbank gespeichert sind. Es 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 Bestandsdetails erleichtert.

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")

Das obige C#-Codefragment wurde entwickelt, um eine HTML-Tabelle mit Bestandsinformationen aus einer SQLite-Datenbank zu erstellen und sie anschließend in eine PDF-Datei zu konvertieren. Es verwendet die Entity Framework Core-Bibliothek, um mit der Datenbank zu interagieren. Zunächst wird ein DbContextOptionsBuilder für die Verwendung von SQLite mit einer bestimmten Verbindungszeichenfolge konfiguriert. Der Code konstruiert dann eine HTML-Zeichenkette mit eingebetteten CSS-Styles für das Erscheinungsbild der Tabelle, erstellt eine Tabellenstruktur mit Überschriften, fragt die SQLite-Datenbank nach Aktieninformationen ab, füllt die HTML-Tabelle mit den abgerufenen Daten auf und verwendet schließlich einen Chrome-basierten PDF-Renderer, um den HTML-Inhalt in eine PDF-Datei namens "stock.pdf" zu konvertieren Die resultierende PDF-Datei enthält eine Tabelle mit Aktiensymbolen, Namen und Preisen.

Die Ausgabe ist wie

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Nutzung von SQLite in .NET für die Datenbankverwaltung eine leichtgewichtige und vielseitige Lösung darstellt. In diesem Artikel wurde die Integration von SQLite in .NET-Anwendungen untersucht, wobei die wichtigsten Funktionen und Vorteile vorgestellt wurden. Der mitgelieferte Code demonstriert praktische Schritte zum Erstellen, Verbinden und Manipulieren einer SQLite-Datenbank in einer .NET-Konsolenanwendung. Außerdem wurde die Verwendung von Microsoft.Data.Sqlite und Entity Framework Core für eine effiziente Datenverarbeitung hervorgehoben. Die Einbindung von IronPDF veranschaulicht, wie man nahtlos einen PDF-Bericht erstellen aus der SQLite-Datenbank, wodurch die Möglichkeiten der Anwendung für die Berichterstattung und Datenverteilung verbessert werden.

IronPDF bietet verschiedene lizenzierungje nach Anzahl der Entwickler, Standorte, Projekte und Umverteilungsbedarf. Die Lizenzen sind unbefristet und beinhalten ein Jahr kostenlosen Support und Updates.