AIDE .NET

Sqlite C# .NET (Fonctionnement pour les développeurs)

Kannapat Udonpant

janvier 14, 2024

SQLite est un moteur de base de données relationnelle populaire, léger et autonome, largement utilisé dans diverses applications d'accès aux données et plates-formes d'environnement. Dans le contexte du développement .NET, le code source de SQLite constitue un excellent choix pour l'intégration d'une solution de contrôle de base de données fiable dans vos applications système. Cet article se penche sur le monde des transactions SQLite, en explorant ses caractéristiques, ses avantages et la manière de l'utiliser efficacement dans vos projets .NET.

Comment utiliser SQLite dans C# ;

Télécharger la bibliothèque SQLite
Créer une base de données et insérer les données
Lire avec le lecteur
Utiliser SQLite en utilisant Entity Framework et la méthode de requête LINQ
Générer un rapport PDF en utilisantIronPDF

Qu'est-ce que SQLite ?

SQLite est un moteur de base de données open-source populaire qui peut être intégré dans des applications sans nécessiter de composant serveur séparé. Il est rapide, fiable et multiplateforme. SQLite peut être utilisé avec les applications du projet .NET grâce à diverses bibliothèques qui fournissent des interfaces ADO.NET. L'une de ces bibliothèques estMicrosoft.Data.SQLite. Cela vous permet d'utiliser SQLite comme source de données pour vos applications .NET, qu'elles soient Console, Desktop, Web ou Mobile. Vous pouvez également utiliser Entity Framework Core pour effectuer un mappage objet-relationnel et interroger votre base de données SQLite à l'aide de LINQ.

Cet article vous montre comment utiliser Microsoft.Data.Sqlite pour développer, connecter et manipuler un SQLite dans une application console .NET. Vous apprendrez à :

Installer le package NuGet Microsoft.Data.Sqlite
Créer une connexion SQLite et exécuter des commandes SQL
Créer et alimenter des tableaux à l'aide de lecteurs de données et de paramètres
Interroger les données à l'aide de lecteurs de données
Mettre en œuvre EntityFramework Core
Interroger les données à l'aide de LINQ
Générer un rapport PDF

Installation de la bibliothèque SQLite

Pour utiliser Microsoft.Data.Sqlite, vous devez installer le paquet NuGet qui contient la bibliothèque et ses dépendances. Vous pouvez le faire à l'aide du gestionnaire de paquets de Visual Studio, de l'interface CLI de .NET Core ou de tout autre outil prenant en charge NuGet. Cet article utilise le gestionnaire de paquets pour créer une application console et installer Microsoft.Data.Sqlite. Pour ce faire, ouvrez une console du Package Manager et exécutez les commandes suivantes :

Install-Package Microsoft.Data.Sqlite

La commande ci-dessus installera le paquet comme indiqué ci-dessous.

Création d'une base de données SQLite

Pour travailler avec une base de données SQLite, vous devez créer un objet SQLiteConnection qui représente la connexion au fichier de la base de données. Vous pouvez spécifier le nom du fichier et d'autres options dans la connexion. Si le fichier n'existe pas, il sera créé automatiquement. Par exemple, le programme ci-dessous crée une connexion à un fichier de base de données nommé employee.db dans le répertoire actuel :

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

L'instruction using garantit que la connexion est fermée et éliminée lorsqu'elle sort du champ d'application. Pour exécuter des commandes SQL, il faut créer un objet SQLiteCommand et l'associer à la connexion. Vous pouvez définir la propriété CommandText en fonction de l'instruction SQL que vous souhaitez exécuter, et éventuellement ajouter des paramètres à la collection Parameters. Vous pouvez ensuite appeler l'une des méthodes de l'objet SQLiteCommand pour exécuter la commande, telle que ExecuteNonQuery, ExecuteScalar ou ExecuteReader.

Créer une table dans SQLite

Le code suivant crée une table nommée Employee à l'aide de la méthode 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

Insérer des données dans un tableau

Pour insérer des données dans une table, vous pouvez utiliser le même objet SQLiteCommand et définir la propriété CommandText avec une instruction INSERT. Par exemple, le code suivant insère trois lignes dans la table Employés.

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

Lire des données à partir de SQLite

Pour lire les données d'une table, vous pouvez utiliser la méthode ExecuteReader de l'objet SQLiteCommand et donner à la propriété CommandText la valeur d'une instruction SELECT. Cet objet renvoie un objet SQLiteDataReader qui vous permet de parcourir les lignes et d'accéder aux valeurs par nom de colonne ou par index. Vous pouvez utiliser la méthode Read pour passer à la ligne suivante et la méthode GetXXX pour obtenir les valeurs dans le type de données approprié. Par exemple, le code suivant lit toutes les lignes du tableau Employés et les imprime sur la console :

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

Sortie

Le résultat de ce code est le suivant :

Sqlite C# .NET(Comment ça marche pour le développeur) : Figure 1 - Sortie

Interroger les données

Si vous préférez utiliser LINQ pour interroger votre base de données SQLite, vous pouvez utiliser Entity Framework Core pour associer vos tables à des classes et effectuer des requêtes à l'aide d'expressions LINQ. Pour ce faire, vous devez installer le paquet Microsoft.EntityFrameworkCore.Sqlite, qui dépend du paquet Microsoft.Data.Sqlite. Vous devez également créer une classe qui hérite de DbContext et représente le contexte de la base de données. Cette classe doit avoir un constructeur qui accepte un paramètre DbContextOptions et le transmet au constructeur de base. Il doit également posséder une propriété DbSet pour chaque table que vous souhaitez associer à une classe. Par exemple, le code suivant définit une classe Stock et une classe 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

Pour créer le contexte de la base de données, vous devez utiliser la classe DbContextOptionsBuilder et spécifier la chaîne de connexion et le fournisseur de la base de données. Vous pouvez également utiliser la méthode Database.EnsureCreated pour créer la base de données et les tables si elles n'existent pas. Par exemple, le code suivant crée le contexte de la base de données et la base de données :

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

Pour insérer des données dans la base de données, vous pouvez utiliser les méthodes Add ou AddRange de la propriété DbSet et transmettre les objets que vous souhaitez insérer. Vous pouvez également utiliser la méthode SaveChanges pour valider les modifications dans la base de données. Par exemple, le code suivant insère trois Stocks dans la base de données :

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

Pour interroger les données, vous pouvez utiliser les méthodes ou expressions LINQ sur la propriété DbSet et appliquer des filtres, des projections, des agrégations et d'autres opérations. Les requêtes seront traduites en instructions SQL et exécutées dans la base de données. Par exemple, le code suivant interroge les actions dont le prix est inférieur à six dollars et imprime leur nom :

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

Supposons que nous ayons besoin de créer un fichier PDF contenant la liste des actions. Nous pouvons facilement le faire en utilisant IronPDF.

Présentation d'IronPDF

IronPDF est une bibliothèque qui vous aide à créer, modifier et lire des fichiers PDF dans vos applications .NET sans avoir besoin de plusieurs packages. Il peut générer des PDF à partir de HTML, d'URL, de JavaScript, de CSS et de nombreux formats d'images, et ajouter des en-têtes, des pieds de page, des signatures, des pièces jointes et des mots de passe. Il prend également en charge la compatibilité multiplateforme, le multithreading et la prise en charge de l'asynchronisme.

IronPDF'sFonctionnalité HTML vers PDF la mise en page est le point fort de la traduction, qui préserve toutes les mises en page et tous les styles. Il génère des PDF à partir de contenus web, ce qui est idéal pour les rapports, les factures et la documentation. Vous pouvez convertir des fichiers HTML, des URL et des chaînes HTML en PDF de manière transparente.

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

Installer IronPDF

Pour installer IronPDF dans notre projet, écrivez la commande suivante dans la console du gestionnaire de paquets.

Install-Package IronPdf

Cette commande installera IronPDF ainsi que toutes ses dépendances.

Ajouter une clé de licence

IronPDF nécessite une clé de licence pour être utilisé. Nous pouvons facilement obtenir une clé de licence d'essai à partir dePage de licence d'essai d'IronPDF.

Ajoutez ce code au démarrage de votre application, avant qu'IronPDF ne soit utilisé. Cette approche fonctionne et est universellement efficace et simple. Il fonctionne pour les applications .NET Core et également pour les applications .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"

Créer un fichier PDF à partir d'une liste de stock

Ce code C# génère un rapport PDF à partir de données de stock stockées dans une base de données SQLite. Il crée dynamiquement un tableau HTML, le remplit avec des informations sur les stocks et utilise un moteur de rendu PDF basé sur Chrome pour convertir le tableau en un fichier "stock.pdf" téléchargeable, ce qui facilite la création de rapports efficaces et la distribution des détails sur les stocks.

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

L'extrait de code C# ci-dessus est conçu pour créer un tableau HTML affichant des informations sur les stocks à partir d'une base de données SQLite et pour le convertir ensuite en fichier PDF. Il utilise la bibliothèque Entity Framework Core pour interagir avec la base de données. Initialement, il configure un DbContextOptionsBuilder pour utiliser SQLite avec une chaîne de connexion spécifique. Le code construit ensuite une chaîne HTML avec des styles CSS intégrés pour l'apparence du tableau, crée une structure de tableau avec des en-têtes, interroge la base de données SQLite pour obtenir des informations sur les actions, remplit le tableau HTML avec les données récupérées et, enfin, utilise un moteur de rendu PDF basé sur Chrome pour convertir le contenu HTML en un fichier PDF nommé "stock.pdf" Le fichier PDF résultant contiendra un tableau présentant les symboles, les noms et les prix des actions.

Le résultat est le suivant

Sqlite C# .NET(Comment ça marche pour le développeur) : Figure 2 - Sortie de la table des stocks

Conclusion

En conclusion, l'utilisation de SQLite dans .NET pour la gestion des bases de données offre une solution légère et polyvalente. Cet article a exploré l'intégration de SQLite dans les applications .NET, en présentant ses principales caractéristiques et ses avantages. Le code fourni démontre les étapes pratiques de la création, de la connexion et de la manipulation d'une base de données SQLite dans une application console .NET. En outre, il a mis en évidence l'utilisation de Microsoft.Data.Sqlite et d'Entity Framework Core pour un traitement efficace des données. L'intégration d'IronPDF a permis d'illustrer la manière dont on peut, de manière transparente, faire des économies d'échellegénérer un rapport PDF à partir de la base de données SQLite, ce qui améliore les capacités de l'application en matière de rapports et de distribution des données.

IronPDF propose différentsoptions de licenceen fonction du nombre de développeurs, de sites, de projets et des besoins de redistribution. Les licences sont perpétuelles et comprennent un an d'assistance et de mises à jour gratuites.

Kannapat Udonpant

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Avant de devenir ingénieur logiciel, Kannapat a obtenu un doctorat en ressources environnementales à l'université d'Hokkaido au Japon. Tout en poursuivant ses études, Kannapat est également devenu membre du Vehicle Robotics Laboratory, qui fait partie du Department of Bioproduction Engineering (département d'ingénierie de la bioproduction). En 2022, il a mis à profit ses compétences en C# pour rejoindre l'équipe d'ingénieurs d'Iron Software, où il se concentre sur IronPDF. Kannapat apprécie son travail car il apprend directement auprès du développeur qui écrit la majeure partie du code utilisé dans IronPDF. Outre l'apprentissage par les pairs, Kannapat apprécie l'aspect social du travail chez Iron Software. Lorsqu'il n'écrit pas de code ou de documentation, Kannapat peut généralement être trouvé en train de jouer sur sa PS5 ou de revoir The Last of Us.

< PRÉCÉDENT
Point d'interrogation double en C# (Comment cela fonctionne pour les développeurs)

SUIVANT >
Datatables .NET (Comment ça fonctionne pour les développeurs)