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 plateformes d'environnement. Dans le cadre du développement .NET, le code source SQLite constitue un excellent choix pour intégrer un contrôle de solution de base de données fiable dans vos applications système. Cet article plonge dans le monde des transactions SQLite, en explorant ses fonctionnalités, avantages, et comment l'utiliser efficacement dans vos projets .NET.
SQLite est un moteur de base de données open-source populaire qui peut être intégré dans des applications sans nécessiter un composant de serveur distinct. Il est rapide, fiable et multiplateforme. SQLite peut être utilisé avec les applications de projet .NET via 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'il s'agisse de console, de bureau, de web ou mobiles. Vous pouvez également utiliser Entity Framework Core pour effectuer un mappage objet-relationnel et interroger votre base de données SQLite en utilisant LINQ.
Cet article vous montre comment utiliser Microsoft.Data.Sqlite pour développer, connecter et manipuler une base de données SQLite dans une application console .NET. Vous apprendrez comment :
Pour utiliser Microsoft.Data.Sqlite, vous devez installer le package NuGet qui contient la bibliothèque et ses dépendances. Vous pouvez le faire en utilisant le gestionnaire de packages Visual Studio, l'interface CLI .NET Core, ou tout autre outil qui prend en charge NuGet. Cet article utilisera le gestionnaire de packages pour créer une application console et installer Microsoft.Data.Sqlite. Pour ce faire, ouvrez une console du gestionnaire de packages et exécutez les commandes suivantes :
La commande ci-dessus installera le package comme indiqué ci-dessous.
Pour travailler avec une base de données SQLite, vous devez créer un objet SqliteConnection qui représente la connexion au fichier de base de données. Vous pouvez spécifier le nom du fichier et d'autres options dans la chaîne de 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 connection = New SqliteConnection("Data Source=employee.db")
connection.Open()
' ...
End UsingL'instruction using garantit que la connexion est fermée et supprimée lorsqu'elle sort de la portée. Pour exécuter des commandes SQL, vous devez créer un objet SqlCommand et l'associer à la connexion. Vous pouvez définir la propriété CommandText sur 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 SqlCommand pour exécuter la commande, comme ExecuteNonQuery, ExecuteScalar ou ExecuteReader.
Le code suivant crée une table nommée Employee en utilisant 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 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 UsingPour insérer des données dans une table, vous pouvez utiliser le même objet SqlCommand et définir la propriété CommandText sur une instruction INSERT. Par exemple, le code suivant insère trois lignes dans la table 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 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 UsingPour lire des données d'une table, vous pouvez utiliser la méthode ExecuteReader de l'objet SqlCommand et définir la propriété CommandText sur une instruction SELECT. Cela retournera 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 les méthodes GetXXX pour obtenir les valeurs sous le type de données approprié. Par exemple, le code suivant lit toutes les lignes de la table Employee et les imprime à 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);
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 UsingLa sortie de ce code est :
Si vous préférez utiliser LINQ pour interroger votre base de données SQLite, vous pouvez utiliser Entity Framework Core pour mapper vos tables à des classes et effectuer des requêtes en utilisant des expressions LINQ. Pour ce faire, vous devez installer le package Microsoft.EntityFrameworkCore.Sqlite, qui dépend du package 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 passe au constructeur de base. Elle doit également avoir une propriété DbSet pour chaque table que vous souhaitez mapper à 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; }
}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 ClassPour 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 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();
}Dim optionsBuilder = New DbContextOptionsBuilder(Of DatabaseContext)()
optionsBuilder.UseSqlite("Data Source=stock.db")
Using context = New DatabaseContext(optionsBuilder.Options)
context.Database.EnsureCreated()
End UsingPour 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 passer 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();
}
}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 SubPour 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 sur la base de données. Par exemple, le code suivant interroge les stocks dont le prix est inférieur à six dollars et imprime leurs noms :
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 UsingSupposons que nous ayons un scénario où nous devons créer un fichier PDF contenant la liste des Stocks. Nous pouvons facilement le faire avec IronPDF.
IronPDF est une bibliothèque qui vous aide à créer, éditer et lire des fichiers PDF dans vos applications .NET sans avoir besoin de plusieurs packages. Il peut générer des PDFs à partir de HTML, URL, JavaScript, CSS et de nombreux formats d'image, ainsi qu'ajouter des en-têtes, pieds de page, signatures, pièces jointes et mots de passe. Il prend également en charge la compatibilité multiplateforme, le multithreading et le support asynchrone.
La fonctionnalité HTML-à-PDF de IronPDF est sa principale caractéristique, préservant toutes les mises en page et styles. Il génère des PDFs à partir de contenu web, idéal pour des rapports, factures et documentation. Vous pouvez convertir des fichiers HTML, des URL, et des chaînes HTML en PDFs facilement.
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 ClassPour installer IronPDF dans notre projet, écrivez la commande suivante dans la console du gestionnaire de packages.
Cette commande installera IronPDF ainsi que toutes ses dépendances.
IronBarcode doit être sous licence pour être utilisé en déploiement.
IronPDF nécessite une clé de licence pour l'utiliser. Nous pouvons facilement obtenir une clé de licence d'essai depuis la page d'essai de licence IronPDF.
Ajoutez ce code à l'initialisation de votre application avant d'utiliser IronPDF. Cette approche est universellement efficace et simple, fonctionnant à la fois pour les applications .NET Core et .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"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 téléchargeable "stock.pdf", facilitant le rapport et la distribution efficace des détails des 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");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")Le fragment 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 le convertir ensuite en un 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 stocks, peuple 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 PDF résultant contiendra un tableau présentant les symboles de stock, les noms et les prix.
En conclusion, l'utilisation de SQLite dans .NET pour la gestion de 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 mettant en évidence ses caractéristiques clés et ses avantages. Le code fourni a démontré des étapes pratiques pour créer, connecter et manipuler une base de données SQLite dans une application console .NET. Il a également souligné l'utilisation de Microsoft.Data.Sqlite et Entity Framework Core pour une gestion efficace des données. L'incorporation d'IronPDF a illustré comment générer de manière fluide un rapport PDF à partir de la base de données SQLite, augmentant les capacités de l'application pour le reporting et la distribution de données.
IronPDF propose diverses options de licence, en fonction du nombre de développeurs, de lieux, de projets, et des besoins de redistribution. Les licences sont perpétuelles et incluent un an de support gratuit et de mises à jour.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
