Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# SQLite
.NET AIDE

SQLite C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Introduction à SQLite

SQLite est un moteur de base de données autonome, sans serveur et sans configuration, utilisé dans diverses applications, y compris les applications de bureau, web et mobiles. Dans ce tutoriel, nous allons plonger dans l'utilisation de SQLite avec C#. À l'aide d'exemples simples et faciles à comprendre, vous apprendrez à créer, gérer et interagir avec une base de données SQLite.

Qu'est-ce que SQLite ?

SQLite est une base de données légère et efficace qui stocke les données dans un seul fichier. Contrairement aux bases de données traditionnelles, elle ne nécessite pas de serveur séparé. Cela en fait un excellent choix pour les applications qui ont besoin d'une base de données sans la complexité d'un système de base de données complet.

Configuration de SQLite en C

Utilisation du gestionnaire de packages NuGet

Pour travailler avec SQLite dans un projet C#, vous devrez installer la bibliothèque SQLite nécessaire. Cela peut être fait via le gestionnaire de packages NuGet.

  1. Ouvrez Visual Studio et créez une nouvelle application Console.
  2. Cliquez avec le bouton droit sur le projet et sélectionnez « Gérer les packages NuGet ».
  3. Recherchez « SQLite » et installez le package.

Établir une connexion

Chaîne de connexion

Une chaîne de connexion est une chaîne qui spécifie des informations sur une source de données et les moyens de s'y connecter. Dans SQLite, la chaîne de connexion ressemblera souvent à ceci :

string connectionString = "Data Source=mydatabase.db;";
string connectionString = "Data Source=mydatabase.db;";
Dim connectionString As String = "Data Source=mydatabase.db;"
$vbLabelText   $csharpLabel

Objet de connexion

Vous pouvez créer un objet de connexion en utilisant la classe SQLiteConnection de l'espace de noms System.Data.SQLite.

using System.Data.SQLite;

// Initialize a connection to the SQLite database
var connection = new SQLiteConnection(connectionString);

// Open the connection
connection.Open();
using System.Data.SQLite;

// Initialize a connection to the SQLite database
var connection = new SQLiteConnection(connectionString);

// Open the connection
connection.Open();
Imports System.Data.SQLite

' Initialize a connection to the SQLite database
Private connection = New SQLiteConnection(connectionString)

' Open the connection
connection.Open()
$vbLabelText   $csharpLabel

Créer une table

Créer une table

Créer une table est fondamental lorsque l'on travaille avec n'importe quelle base de données. Voici comment créer une table en utilisant le code SQLite.

// SQL command to create a new table "person"
string query = "CREATE TABLE IF NOT EXISTS person (id INTEGER PRIMARY KEY, name TEXT)";

// Create a command object with the SQL query and connection
var command = new SQLiteCommand(query, connection);

// Execute the command to create the table
command.ExecuteNonQuery();
// SQL command to create a new table "person"
string query = "CREATE TABLE IF NOT EXISTS person (id INTEGER PRIMARY KEY, name TEXT)";

// Create a command object with the SQL query and connection
var command = new SQLiteCommand(query, connection);

// Execute the command to create the table
command.ExecuteNonQuery();
' SQL command to create a new table "person"
Dim query As String = "CREATE TABLE IF NOT EXISTS person (id INTEGER PRIMARY KEY, name TEXT)"

' Create a command object with the SQL query and connection
Dim command = New SQLiteCommand(query, connection)

' Execute the command to create the table
command.ExecuteNonQuery()
$vbLabelText   $csharpLabel
  • Id Integer Primary Key : Définit la colonne 'id' comme clé primaire.
  • Nom de la table : Le nom que vous souhaitez donner à votre table de base de données.

Insertion de données

Insérer des lignes

Pour insérer des données dans une table, vous devrez utiliser une commande INSERT.

// SQL command to insert a new row into the "person" table
string query = "INSERT INTO person (name) VALUES ('John')";
var command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();
// SQL command to insert a new row into the "person" table
string query = "INSERT INTO person (name) VALUES ('John')";
var command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();
' SQL command to insert a new row into the "person" table
Dim query As String = "INSERT INTO person (name) VALUES ('John')"
Dim command = New SQLiteCommand(query, connection)
command.ExecuteNonQuery()
$vbLabelText   $csharpLabel

Commande paramétrée

Les commandes paramétrées peuvent protéger votre application contre les attaques par injection SQL. Cette approche utilise des paramètres au lieu d'insérer directement des valeurs dans la requête.

// SQL command with a parameter to insert data safely
string query = "INSERT INTO person (name) VALUES (@name)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@name", "Iron Developer");
command.ExecuteNonQuery();
// SQL command with a parameter to insert data safely
string query = "INSERT INTO person (name) VALUES (@name)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@name", "Iron Developer");
command.ExecuteNonQuery();
' SQL command with a parameter to insert data safely
Dim query As String = "INSERT INTO person (name) VALUES (@name)"
Dim command = New SQLiteCommand(query, connection)
command.Parameters.AddWithValue("@name", "Iron Developer")
command.ExecuteNonQuery()
$vbLabelText   $csharpLabel

Récupération de données

Instruction Select

Pour récupérer des données de la table de la base de données, utilisez une instruction SELECT.

// SQL command to select all rows from the "person" table
string query = "SELECT * FROM person";

var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();

// Loop through the result set and read data
while (reader.Read())
{
    Console.WriteLine(reader["name"]);
}
// SQL command to select all rows from the "person" table
string query = "SELECT * FROM person";

var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();

// Loop through the result set and read data
while (reader.Read())
{
    Console.WriteLine(reader["name"]);
}
' SQL command to select all rows from the "person" table
Dim query As String = "SELECT * FROM person"

Dim command = New SQLiteCommand(query, connection)
Dim reader = command.ExecuteReader()

' Loop through the result set and read data
Do While reader.Read()
	Console.WriteLine(reader("name"))
Loop
$vbLabelText   $csharpLabel

Fonctionnalités avancées

Transactions SQLite

Les transactions vous permettent d'exécuter plusieurs opérations dans une seule action atomique. Voici comment utiliser les transactions :

var transaction = connection.BeginTransaction();
try
{
    // Example of multiple operations in a transaction
    var insertCommand = new SQLiteCommand("INSERT INTO person (name) VALUES ('Alice')", connection, transaction);
    insertCommand.ExecuteNonQuery();

    var updateCommand = new SQLiteCommand("UPDATE person SET name = 'Bob' WHERE name = 'Alice'", connection, transaction);
    updateCommand.ExecuteNonQuery();

    transaction.Commit(); // Commit the transaction if all operations succeed
}
catch
{
    transaction.Rollback(); // Rollback the transaction if any operation fails
}
var transaction = connection.BeginTransaction();
try
{
    // Example of multiple operations in a transaction
    var insertCommand = new SQLiteCommand("INSERT INTO person (name) VALUES ('Alice')", connection, transaction);
    insertCommand.ExecuteNonQuery();

    var updateCommand = new SQLiteCommand("UPDATE person SET name = 'Bob' WHERE name = 'Alice'", connection, transaction);
    updateCommand.ExecuteNonQuery();

    transaction.Commit(); // Commit the transaction if all operations succeed
}
catch
{
    transaction.Rollback(); // Rollback the transaction if any operation fails
}
Dim transaction = connection.BeginTransaction()
Try
	' Example of multiple operations in a transaction
	Dim insertCommand = New SQLiteCommand("INSERT INTO person (name) VALUES ('Alice')", connection, transaction)
	insertCommand.ExecuteNonQuery()

	Dim updateCommand = New SQLiteCommand("UPDATE person SET name = 'Bob' WHERE name = 'Alice'", connection, transaction)
	updateCommand.ExecuteNonQuery()

	transaction.Commit() ' Commit the transaction if all operations succeed
Catch
	transaction.Rollback() ' Rollback the transaction if any operation fails
End Try
$vbLabelText   $csharpLabel

Mapping Objet-Relationnel (ORM) avec Entity Framework

Entity Framework (EF) est un outil ORM largement utilisé dans l'écosystème .NET. Il simplifie la programmation des bases de données en permettant aux développeurs de travailler avec des données relationnelles en utilisant des objets spécifiques au domaine. Voici comment vous pouvez utiliser Entity Framework avec SQLite.

1. Installation d'Entity Framework

Tout d'abord, assurez-vous d'avoir installé le package NuGet d'Entity Framework spécifique à SQLite :

  1. Ouvrez le gestionnaire de packages NuGet dans Visual Studio.
  2. Recherchez « Entity Framework SQLite » et installez-le.

2. Création de classes d'entité

Les classes d'entité sont des représentations des tables de la base de données. Vous pouvez créer une classe pour chaque table avec laquelle vous avez l'intention d'interagir.

public class Person
{
    public int Id { get; set; } // Primary Key
    public string Name { get; set; }
}
public class Person
{
    public int Id { get; set; } // Primary Key
    public string Name { get; set; }
}
Public Class Person
	Public Property Id() As Integer ' -  Primary Key
	Public Property Name() As String
End Class
$vbLabelText   $csharpLabel

3. DbContext

Vous devrez créer une classe qui hérite de DbContext. Cette classe représente la session avec la base de données et vous permet de requêter et de sauvegarder des instances des entités.

using Microsoft.EntityFrameworkCore;

public class MyDbContext : DbContext
{
    public DbSet<Person> Persons { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite("Data Source=mydatabase.db;");
    }
}
using Microsoft.EntityFrameworkCore;

public class MyDbContext : DbContext
{
    public DbSet<Person> Persons { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite("Data Source=mydatabase.db;");
    }
}
Imports Microsoft.EntityFrameworkCore

Public Class MyDbContext
	Inherits DbContext

	Public Property Persons() As DbSet(Of Person)

	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		optionsBuilder.UseSqlite("Data Source=mydatabase.db;")
	End Sub
End Class
$vbLabelText   $csharpLabel

4. Opérations CRUD

Entity Framework simplifie les opérations de création, de lecture, de mise à jour et de suppression (CRUD). Voici comment vous pouvez insérer un nouvel enregistrement :

using (var db = new MyDbContext())
{
    db.Persons.Add(new Person { Name = "John" });
    db.SaveChanges();
}
using (var db = new MyDbContext())
{
    db.Persons.Add(new Person { Name = "John" });
    db.SaveChanges();
}
Using db = New MyDbContext()
	db.Persons.Add(New Person With {.Name = "John"})
	db.SaveChanges()
End Using
$vbLabelText   $csharpLabel

La lecture, la mise à jour et la suppression d'enregistrements sont également simplifiées et directes avec Entity Framework, permettant un code concis et maintenable.

Travailler avec des fichiers XML et d'autres fournisseurs de données

SQLite n'est pas limité aux données relationnelles ; il offre également de la flexibilité pour gérer d'autres types de données, y compris les fichiers XML.

1. Stockage de données XML

Vous pouvez stocker des données XML dans une base de données SQLite. Cela peut être utile si vous travaillez avec des données de configuration ou d'autres structures hiérarchiques.

string xmlData = "<person><name>John</name></person>";
string query = "INSERT INTO xmltable (data) VALUES (@data)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@data", xmlData);
command.ExecuteNonQuery();
string xmlData = "<person><name>John</name></person>";
string query = "INSERT INTO xmltable (data) VALUES (@data)";
var command = new SQLiteCommand(query, connection);
command.Parameters.AddWithValue("@data", xmlData);
command.ExecuteNonQuery();
Dim xmlData As String = "<person><name>John</name></person>"
Dim query As String = "INSERT INTO xmltable (data) VALUES (@data)"
Dim command = New SQLiteCommand(query, connection)
command.Parameters.AddWithValue("@data", xmlData)
command.ExecuteNonQuery()
$vbLabelText   $csharpLabel

Récupération de données XML

Vous pouvez récupérer et travailler avec des données XML en utilisant des techniques standard d'analyse XML en C#.

string query = "SELECT data FROM xmltable WHERE id = 1";
var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();

string xmlData;

// Read the XML data from the query result
if (reader.Read())
{
    xmlData = reader["data"].ToString();
}

// Parse the XML data as needed using an XML parser
string query = "SELECT data FROM xmltable WHERE id = 1";
var command = new SQLiteCommand(query, connection);
var reader = command.ExecuteReader();

string xmlData;

// Read the XML data from the query result
if (reader.Read())
{
    xmlData = reader["data"].ToString();
}

// Parse the XML data as needed using an XML parser
Dim query As String = "SELECT data FROM xmltable WHERE id = 1"
Dim command = New SQLiteCommand(query, connection)
Dim reader = command.ExecuteReader()

Dim xmlData As String

' Read the XML data from the query result
If reader.Read() Then
	xmlData = reader("data").ToString()
End If

' Parse the XML data as needed using an XML parser
$vbLabelText   $csharpLabel

Travailler avec d'autres fournisseurs de données

SQLite s'intègre également bien avec divers fournisseurs de données, permettant interopérabilité et flexibilité. Cela signifie que vous pouvez passer en toute transparence entre différentes bases de données ou même combiner différentes sources de données dans une seule application.

Présentation de l'Iron Suit : un ensemble puissant de bibliothèques

Après avoir exploré les domaines de SQLite et les opérateurs logiques en C#, il est temps de présenter une collection remarquable d'outils qui complètent et améliorent l'expérience de développement dans l'environnement .NET. L'Iron Suit est une collection de bibliothèques puissantes comprenant IronPDF, IronXL, IronOCR et IronBarcode, chacune servant des objectifs distincts.

IronPDF : bibliothèque PDF pour C

Guide complet d'IronPDF est une bibliothèque complète conçue pour créer, lire et manipuler des fichiers PDF en C#. Que vous ayez besoin de générer des rapports, des factures ou tout document au format PDF, IronPDF est là pour vous. Une caractéristique unique d'IronPDF est la capacité de convertir du HTML en PDF. Vous pouvez rendre du HTML en tant que document PDF, y compris CSS, JavaScript et images, ce qui en fait un outil puissant. Consultez ce tutoriel sur Conversion de HTML en PDF avec IronPDF pour un guide étape par étape.

La fonctionnalité HTML vers PDF d'IronPDF est son principal atout, 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");
    }
}
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

IronPDF peut être un outil essentiel lorsque vous travaillez avec des bases de données SQLite. Vous pouvez générer des rapports PDF à partir de vos données de base de données SQLite, permettant une présentation et un partage des données fluides.

IronXL : gestion de fichiers Excel facilitée

Explorez IronXL pour l'intégration Excel qui permet aux développeurs de lire, écrire et manipuler des fichiers Excel sans effort. Il est compatible avec XLS, XLSX, etc., ce qui en fait un outil idéal pour gérer les données des feuilles de calcul. Vous pouvez lire des fichiers Excel, les manipuler et même créer de nouveaux fichiers à partir de zéro. Les fonctionnalités d'IronXL s'intègrent bien à la gestion de bases de données, y compris SQLite, pour exporter et importer des données.

IronOCR : reconnaissance optique de caractères en C

Avec IronOCR pour la reconnaissance de texte, numériser du texte à partir d'images et de fichiers PDF est un jeu d'enfant. C'est une bibliothèque OCR (Reconnaissance Optique de Caractères) polyvalente qui reconnaît le texte de diverses sources.

Imaginez stocker des documents numérisés dans une base de données SQLite et utiliser IronOCR pour récupérer et reconnaître le texte dans ces documents. Les possibilités sont infinies, offrant une puissante fonction de récupération de texte et de recherche.

IronBarcode : la bibliothèque ultime de génération et lecture de codes-barres

La génération et la lecture de codes-barres sont simplifiées avec Intégration de codes-barres puissante via IronBarcode. Il supporte plusieurs formats de codes-barres et offre une API robuste pour tous les besoins liés aux codes-barres. IronBarcode peut jouer un rôle essentiel dans les applications utilisant SQLite, où les codes-barres pourraient représenter des produits ou d'autres entités de données. Stocker et récupérer des codes-barres à partir de la base de données SQLite améliore l'intégrité des données et facilite un accès rapide.

Conclusion

SQLite est un moteur de base de données puissant mais léger qui est excellent pour les débutants comme pour les professionnels. De la création de tables et de l'insertion de lignes à la gestion des transactions et à la prévention des attaques par injection SQL, SQLite offre de nombreuses fonctionnalités. Que vous développiez une application console ou mobile ou que vous ayez besoin de travailler avec des clés étrangères et des ensembles de données, SQLite est un excellent choix.

L'Iron Suit, composée d'IronPDF, IronXL, IronOCR et IronBarcode, est une mine d'outils qui étendent les capacités de vos projets de développement C#, que vous travailliez avec des bases de données SQLite ou d'autres domaines.

Ce qui est encore plus attrayant, c'est que chacun de ces produits offre un essai gratuit pour les produits Iron Software, vous donnant suffisamment de temps pour explorer et comprendre la vaste gamme de fonctionnalités qu'ils offrent. Une fois que vous décidez de continuer avec ces outils, les licences commencent à partir de $799 par produit. Vous pouvez également acheter le pack complet Iron Suit au prix de seulement deux produits individuels.

Questions Fréquemment Posées

Comment puis-je configurer SQLite dans un projet C# en utilisant NuGet ?

Pour configurer SQLite dans un projet C# en utilisant NuGet, ouvrez Visual Studio et créez une nouvelle application Console. Accédez au gestionnaire de packages NuGet, recherchez 'SQLite', et installez le package. Cela intégrera les bibliothèques SQLite dans votre projet pour les opérations de base de données.

Quels sont les avantages d'utiliser SQLite pour les applications C# ?

SQLite est un moteur de base de données léger et sans serveur qui stocke les données dans un seul fichier, ce qui le rend idéal pour les applications nécessitant une solution de base de données simple et efficace sans la complexité d'un système de base de données traditionnel.

Comment puis-je me connecter à une base de données SQLite en C# ?

Vous pouvez vous connecter à une base de données SQLite en C# en créant une chaîne de connexion comme Data Source=mydatabase.db; et en utilisant la classe SQLiteConnection du namespace System.Data.SQLite pour établir et ouvrir une connexion.

Comment puis-je exécuter des opérations CRUD sur une base de données SQLite en utilisant C# ?

En utilisant des commandes SQL telles que INSERT, SELECT, UPDATE, et DELETE, vous pouvez effectuer des opérations CRUD sur une base de données SQLite en C#. Ces commandes peuvent être exécutées à l'aide d'un objet SQLiteCommand.

Quel rôle jouent les transactions dans SQLite ?

Les transactions dans SQLite permettent d'exécuter plusieurs opérations comme une seule action atomique. Vous pouvez débuter une transaction en utilisant connection.BeginTransaction(), effectuer les opérations nécessaires, puis valider ou annuler la transaction en fonction du résultat.

Comment puis-je utiliser Entity Framework avec SQLite dans un projet C# ?

Pour utiliser Entity Framework avec SQLite, installez le package nécessaire d'Entity Framework via NuGet, définissez vos classes d'entité et créez une classe DbContext. Cette configuration permet la mappage objet-relationnel, simplifiant les interactions avec la base de données dans votre projet C#.

Comment puis-je générer des documents PDF à partir des données de la base de données en utilisant C# ?

Avec IronPDF, vous pouvez générer des documents PDF à partir des données de la base de données en C# en convertissant du HTML en PDF. Cela vous permet de créer des rapports PDF bien formatés à partir des données stockées dans votre base de données SQLite.

Quels outils peuvent améliorer le développement en C# pour les applications de base de données ?

L'Iron Suit, qui inclut des outils tels qu'IronPDF, IronXL, IronOCR, et IronBarcode, améliore le développement en C# pour les applications de base de données en fournissant des fonctionnalités comme la création de PDF, la manipulation de fichiers Excel, la reconnaissance de texte et la génération de codes-barres.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit