Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. Sqlite C# .NET
POMOC .NET

Sqlite C# .NET (jak to działa dla programistów)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

SQLite to popularny, lekki i samowystarczalny silnik relacyjnej bazy danych, szeroko stosowany w różnych aplikacjach dostępu do danych i platformach środowiskowych. W kontekście programowania w środowisku .NET kod źródłowy SQLite stanowi doskonały wybór do zintegrowania niezawodnego rozwiązania bazodanowego z aplikacjami systemowymi. W tym artykule zagłębimy się w świat transakcji SQLite, badając ich funkcje, zalety oraz sposoby efektywnego wykorzystania w projektach .NET.

Jak korzystać z SQLite w C

  1. Pobierz bibliotekę SQLite
  2. Utwórz bazę danych i wprowadź dane
  3. Czytaj przy użyciu czytnika
  4. Korzystanie z SQLite przy użyciu Entity Framework i metody zapytań LINQ
  5. Generowanie raportu PDF za pomocą IronPDF

Czym jest SQLite?

SQLite to popularny silnik baz danych typu open source, który można osadzić w aplikacjach bez konieczności stosowania oddzielnego komponentu serwerowego. Jest szybki, niezawodny i działa na wielu platformach. SQLite może być używany w aplikacjach projektów .NET za pośrednictwem różnych bibliotek zapewniających interfejsy ADO.NET. Jedną z tych bibliotek jest Microsoft.Data.SQLite. Dzięki temu możesz używać SQLite jako źródła danych dla swoich aplikacji .NET, niezależnie od tego, czy są to aplikacje konsolowe, desktopowe, internetowe czy mobilne. Możesz również używać Entity Framework Core do mapowania obiektowo-relacyjnego i wysyłania zapytań do bazy danych SQLite za pomocą LINQ.

W tym artykule pokazano, jak używać Microsoft.Data.Sqlite do tworzenia, łączenia się i manipulowania bazą danych SQLite w aplikacji konsolowej .NET. Dowiesz się, jak:

  • Zainstaluj pakiet NuGet Microsoft.Data.Sqlite
  • Utwórz połączenie SQLite i wykonaj polecenia SQL
  • Tworzenie i wypełnianie tabel przy użyciu czytników danych i parametrów
  • Pobieranie danych za pomocą czytników danych
  • Wdrożenie EntityFramework Core
  • Pobieranie danych za pomocą LINQ
  • Wygeneruj raport PDF

Instalacja biblioteki SQLite

Aby korzystać z Microsoft.Data.Sqlite, należy zainstalować pakiet NuGet zawierający bibliotekę i jej zależności. Można to zrobić za pomocą menedżera pakietów Visual Studio, interfejsu CLI .NET Core lub dowolnego innego narzędzia obsługującego NuGet. W tym artykule użyjemy Menedżera pakietów do utworzenia aplikacji konsolowej i zainstalowania biblioteki Microsoft.Data.Sqlite. Aby to zrobić, otwórz konsolę Menedżera pakietów i uruchom następujące polecenia:

Install-Package Microsoft.Data.Sqlite

Powyższe polecenie zainstaluje pakiet w sposób pokazany poniżej.

Tworzenie bazy danych SQLite

Aby pracować z bazą danych SQLite, należy utworzyć obiekt SqliteConnection reprezentujący połączenie z plikiem bazy danych. W ciągu połączenia można określić nazwę pliku i inne opcje. Jeśli plik nie istnieje, zostanie utworzony automatycznie. Na przykład poniższy program tworzy połączenie z plikiem bazy danych o nazwie employee.db w bieżącym katalogu:

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

Instrukcja using gwarantuje, że połączenie zostanie zamknięte i usunięte, gdy wykracza poza zakres. Aby wykonać polecenia SQL, należy utworzyć obiekt SqlCommand i powiązać go z połączeniem. Możesz ustawić właściwość CommandText na instrukcję SQL, którą chcesz wykonać, i opcjonalnie dodać parametry do kolekcji Parameters. Następnie można wywołać jedną z metod obiektu SqlCommand, aby wykonać polecenie, na przykład ExecuteNonQuery, ExecuteScalar lub ExecuteReader.

Utwórz tabelę w SQLite

Poniższy kod tworzy tabelę o nazwie Employee przy użyciu metody 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 (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

Wstaw dane do tabeli

Aby wstawić dane do tabeli, można użyć tego samego obiektu SqlCommand i ustawić właściwość CommandText na instrukcję INSERT. Na przykład poniższy kod wstawia trzy wiersze do tabeli Employee.

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

Odczyt danych z SQLite

Aby odczytać dane z tabeli, można użyć metody ExecuteReader obiektu SqlCommand i ustawić właściwość CommandText na instrukcję SELECT. Zwróci to obiekt SqliteDataReader, który pozwala na iterację po wierszach i dostęp do wartości według nazwy kolumny lub indeksu. Można użyć metody Read, aby przejść do następnego wiersza, oraz metod GetXXX, aby uzyskać wartości jako odpowiedni typ danych. Na przykład poniższy kod odczytuje wszystkie wiersze z tabeli Employee i wyświetla je w konsoli:

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

Wynik

Wynikiem działania tego kodu jest:

Sqlite C# .NET (Jak to działa dla programisty): Rysunek 1 – Wynik

Wyszukiwanie danych

Jeśli wolisz używać LINQ do wysyłania zapytań do bazy danych SQLite, możesz skorzystać z Entity Framework Core, aby zmapować tabele do klas i wykonywać zapytania przy użyciu wyrażeń LINQ. W tym celu należy zainstalować pakiet Microsoft.EntityFrameworkCore.Sqlite, który jest zależny od pakietu Microsoft.Data.Sqlite. Należy również utworzyć klasę dziedziczącą po DbContext i reprezentującą kontekst bazy danych. Ta klasa musi posiadać konstruktor, który przyjmuje parametr DbContextOptions i przekazuje go do konstruktora bazowego. Musi również posiadać właściwość DbSet dla każdej tabeli, którą chcesz zmapować do klasy. Na przykład poniższy kod definiuje klasę Stock oraz klasę DatabaseContext:

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

Aby utworzyć kontekst bazy danych, należy użyć klasy DbContextOptionsBuilder oraz określić ciąg połączenia i dostawcę bazy danych. Można również użyć metody Database.EnsureCreated do utworzenia bazy danych i tabel, jeśli jeszcze nie istnieją. Na przykład poniższy kod tworzy kontekst bazy danych oraz samą bazę danych:

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

Aby wstawić dane do bazy danych, można użyć metod Add lub AddRange właściwości DbSet i przekazać obiekty, które chcesz wstawić. Możesz również użyć metody SaveChanges, aby zatwierdzić zmiany w bazie danych. Na przykład poniższy kod wstawia trzy akcje do bazy danych:

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

Aby wyszukiwać dane, można użyć metod lub wyrażeń LINQ na właściwości DbSet oraz zastosować filtry, projekcje, agregacje i inne operacje. Zapytania zostaną przetłumaczone na instrukcje SQL i wykonane w bazie danych. Na przykład poniższy kod wyszukuje akcje, których cena jest niższa niż sześć dolarów, i PRINTuje ich nazwy:

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

Załóżmy, że mamy scenariusz, w którym musimy utworzyć plik PDF zawierający listę akcji. Możemy to łatwo osiągnąć, korzystając z IronPDF.

Przedstawiamy IronPDF

IronPDF to biblioteka, która pomaga tworzyć, edytować i odczytywać pliki PDF w aplikacjach .NET bez konieczności korzystania z wielu pakietów. Może generować pliki PDF z HTML, adresów URL, JavaScript, CSS i wielu formatów obrazów, a także dodawać nagłówki, stopki, podpisy, załączniki i hasła. Obsługuje również kompatybilność międzyplatformową, wielowątkowość i obsługę asynchroniczną.

Główną zaletą IronPDF jest funkcja konwersji HTML do PDF, która zachowuje wszystkie układy i style. Generuje pliki PDF na podstawie treści internetowych, co idealnie nadaje się do raportów, faktur i dokumentacji. Możesz płynnie konwertować pliki HTML, adresy URL i ciągi znaków HTML do formatu 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");
    }
}
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

Zainstaluj IronPDF

Aby zainstalować IronPDF w naszym projekcie, wpisz następujące polecenie w konsoli menedżera pakietów.

Install-Package IronPdf

To polecenie zainstaluje IronPDF wraz ze wszystkimi jego zależnościami.

Dodaj klucz licencyjny

Aby korzystać z IronPDF, wymagany jest klucz licencyjny. Klucz licencji Trial można łatwo uzyskać na stronie licencji Trial IronPDF.

Dodaj ten kod do sekcji startup swojej aplikacji przed użyciem IronPDF. To podejście jest uniwersalne i proste, sprawdzające się zarówno w przypadku aplikacji .NET Core, jak i .NET Framework.

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

Utwórz plik PDF zawierający listę akcji

Ten kod w języku C# generuje raport w formacie PDF na podstawie danych giełdowych przechowywanych w bazie danych SQLite. Dynamicznie tworzy tabelę HTML, wypełnia ją informacjami o akcjach i wykorzystuje renderer PDF oparty na przeglądarce Chrome do konwersji tabeli na plik "stock.pdf" do pobrania, ułatwiając efektywne raportowanie i dystrybucję szczegółowych informacji o akcjach.

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 System.Text
Imports Microsoft.EntityFrameworkCore

Dim optionsBuilder As 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 As 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
End Using
builder.Append("</table></body></html>")
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(builder.ToString())
pdf.SaveAs("stock.pdf")
$vbLabelText   $csharpLabel

Powyższy fragment kodu w języku C# służy do tworzenia tabeli HTML wyświetlającej informacje o akcjach z bazy danych SQLite, a następnie konwertowania jej do pliku PDF. Wykorzystuje bibliotekę Entity Framework Core do interakcji z bazą danych. Początkowo konfiguruje DbContextOptionsBuilder do korzystania z SQLite przy użyciu określonego ciągu połączenia. Następnie kod tworzy ciąg HTML z osadzonymi stylami CSS określającymi wygląd tabeli, tworzy strukturę tabeli z nagłówkami, wysyła zapytanie do bazy danych SQLite w celu uzyskania informacji o akcjach, wypełnia tabelę HTML pobranymi danymi, a na koniec wykorzystuje renderer PDF oparty na przeglądarce Chrome do konwersji treści HTML do pliku PDF o nazwie "stock.pdf". Powstały plik PDF będzie zawierał tabelę przedstawiającą symbole akcji, nazwy i ceny.

Wynik jest następujący:

Sqlite C# .NET (Jak to działa dla programisty): Rysunek 2 – Wynik tabeli akcji

Wnioski

Podsumowując, wykorzystanie SQLite w .NET do zarządzania bazami danych stanowi lekkie i wszechstronne rozwiązanie. W tym artykule omówiono integrację SQLite z aplikacjami .NET, przedstawiając jego kluczowe funkcje i zalety. Podany kod pokazuje praktyczne kroki tworzenia, łączenia i manipulowania bazą danych SQLite w aplikacji konsolowej .NET. Ponadto podkreślono wykorzystanie bibliotek Microsoft.Data.Sqlite i Entity Framework Core do wydajnej obsługi danych. Włączenie IronPDF pokazało, jak płynnie generować raporty PDF z bazy danych SQLite, zwiększając możliwości aplikacji w zakresie raportowania i dystrybucji danych.

IronPDF oferuje różne opcje licencyjne w zależności od liczby programistów, lokalizacji, projektów i potrzeb związanych z redystrybucją. Licencje są bezterminowe i obejmują rok bezpłatnego wsparcia technicznego oraz aktualizacji.

Często Zadawane Pytania

Czym jest SQLite i dlaczego jest popularny w programowaniu .NET?

SQLite to lekki i samowystarczalny silnik relacyjnej bazy danych, który jest szeroko stosowany w programowaniu .NET ze względu na swoją szybkość, niezawodność i możliwości wieloplatformowe. Można go osadzić w aplikacjach bez konieczności stosowania oddzielnego komponentu serwerowego.

Jak mogę zintegrować SQLite z moją aplikacją .NET?

Możesz zintegrować SQLite ze swoją aplikacją .NET, instalując pakiet NuGet Microsoft.Data.Sqlite. Zapewnia on interfejsy ADO.NET, umożliwiające tworzenie, łączenie się i manipulowanie bazami danych SQLite w aplikacjach konsolowych, desktopowych, internetowych lub mobilnych.

Jak utworzyć bazę danych SQLite i połączyć się z nią w języku C#?

Aby utworzyć bazę danych SQLite i połączyć się z nią w języku C#, należy użyć klasy SqliteConnection do nawiązania połączenia. Następnie można wykonywać polecenia SQL w celu tworzenia tabel i manipulowania danymi za pomocą obiektu SqlCommand.

Czy mogę używać zapytań LINQ z SQLite w .NET?

Tak, można używać zapytań LINQ z SQLite w .NET, korzystając z Entity Framework Core. Umożliwia to mapowanie obiektowo-relacyjne, pozwalając na wykonywanie zapytań LINQ na właściwościach DbSet w klasie DbContext.

Jak mogę generować raporty PDF na podstawie danych z bazy danych SQLite?

Za pomocą IronPDF można generować raporty PDF na podstawie danych z bazy danych SQLite. Konwertując reprezentacje danych w formacie HTML lub korzystając bezpośrednio z zawartości bazy danych, można tworzyć szczegółowe raporty PDF i eksportować je, wykorzystując możliwości renderowania IronPDF.

Jak rozwiązywać typowe problemy związane z SQLite w aplikacjach .NET?

Typowe problemy związane z SQLite w aplikacjach .NET można rozwiązać, upewniając się, że pakiet Microsoft.Data.Sqlite jest poprawnie zainstalowany, sprawdzając składnię SQL oraz weryfikując ciągi połączeń. Narzędzia do debugowania i logi również mogą pomóc w identyfikacji i usuwaniu błędów.

Jak zainstalować i używać bibliotekę PDF w projekcie .NET?

Aby zainstalować bibliotekę PDF, taką jak IronPDF, w projekcie .NET, uruchom polecenie Install-Package IronPdf w konsoli menedżera pakietów. Po zainstalowaniu IronPDF umożliwia tworzenie, edycję i odczyt plików PDF przy użyciu rozbudowanego interfejsu API.

Jakie są zalety korzystania z SQLite w środowisku .NET?

Korzystanie z SQLite w środowisku .NET oferuje takie zalety, jak prostota, brak konieczności posiadania oddzielnego serwera, obsługa wielu platform oraz niezawodna wydajność. Jest to idealne rozwiązanie dla lekkich aplikacji i można je łatwo zintegrować za pomocą bibliotek takich jak Microsoft.Data.Sqlite.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie