1. IronPDF
  2. IronPDF Blog
  3. aide .NET
  4. Sqlite C# .NET
AIDE .NET

Sqlite C# .NET (Comment ça marche pour le développeur)

Publié janvier 14, 2024
Partager:

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# ;

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

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 est Microsoft.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
VB   C#

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
VB   C#

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
VB   C#

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
VB   C#

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
VB   C#

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
VB   C#

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
VB   C#

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
VB   C#

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, éditeret lire 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, ainsi que de ajouter des en-têtes, pieds de page, signatures, pièces jointeset mots de passe. Il prend également en charge la compatibilité multiplateforme, le multithreading et la prise en charge de l'asynchronisme.

IronPDF's HTML vers PDF est son principal atout, car elle 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
VB   C#

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 de ici.

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"
VB   C#

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")
VB   C#

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'échelle gé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érents octroi de licencesen 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.

< PRÉCÉDENT
Point d'interrogation double en C# (Comment ça marche pour le développeur)
SUIVANT >
Datatables .NET (Comment ça marche pour le développeur)

Signaler un problème

Prêt à commencer ? Version : 2024.9 vient de paraître

Téléchargement gratuit de NuGet Nombre total de téléchargements : 10,746,704 Voir les licences > ;

Obtenez GRATUITEMENT votre

clé d'évaluation de 30 jours instantanément.

clé d'évaluation de 15 jours instantanément.

bullet_checkedAucune carte de crédit ou création de compte n'est nécessaire
Le formulaire d'essai a été soumis
avec succès.

Votre clé d'essai devrait se trouver dans l'e-mail.
Si ce n'est pas le cas, veuillez contacter
support@ironsoftware.com

bullet_testTest en production
sans filigrane
bullet_calendar30 jours entièrement
produit fonctionnel
bullet_support24/5 technique
soutien pendant le procès

Merci de votre attention !

Votre clé de licence a été envoyée à l'adresse électronique fournie.Contactez nous

offre de surclassement dans les 24 heures :

Save 50% sur un
Professionnel Mise à niveau

Aller Professionnel pour couvrir 10 développeurs
et des projets illimités.

heures

:

minutes

:

secondes

Passer à la version professionnelle

Mise à niveau

Professionnel

$600 USD

$299 USD

  • 10 développeurs
  • 10 emplacements
  • 10 projets
AUJOURD'HUI UNIQUEMENT

5 produits .NET pour le prix de 2

IronPDF IronOCR IronXL IronBarcode IronWebscraper

Valeur totale de la suite :

$7,192 USD

Prix du surclassement

AUJOURD'HUI
UNIQUEMENT

$499 USD

Après 24 heures

$1,098 USD