Dapper C# (Comment ça marche pour les développeurs)

Introduction

Dans le développement de logiciels modernes, l'accès efficace aux bases de données est crucial pour la performance et l'évolutivité des applications. Dapperun mappeur objet-relationnel léger (ORM) pour .NET, offre une approche simplifiée de l'interaction avec les bases de données. Dans cet article, nous allons explorer comment utiliser Dapper C# avec un fichier de base de données SQLite, en démontrant sa simplicité et son efficacité à travers des exemples de code. En outre, je présenterai la remarquable bibliothèque de génération de PDF appelée IronPDF de Iron Software.

Qu'est-ce que Dapper ?

Dapper est un mappage objet-relationnel (ORM) pour la plate-forme .NET. Il s'agit d'un simple mappeur d'objets qui vous permet de faire correspondre un modèle de domaine orienté objet à une base de données relationnelle traditionnelle. Dapper est connu pour sa rapidité et ses performances, et est souvent considéré comme le "roi des ORM micro" Il égale la vitesse d'un lecteur de données ADO.NET brut et améliore l'interface IDbConnection avec des méthodes d'extension utiles pour l'interrogation des bases de données SQL.

Principales caractéristiques de Dapper

1. Performances : Dapper est connu pour ses excellentes performances grâce à sa conception légère et à son mappage efficace des objets.
2. Simplicité : L'API de Dapper est minimaliste et intuitive, ce qui permet aux développeurs de la comprendre et de l'utiliser efficacement.
3. Support SQL brut : Dapper permet aux développeurs d'écrire des requêtes SQL brutes, offrant un contrôle total sur les interactions avec la base de données.
4. Mappage d'objets : Dapper mappe les résultats des requêtes directement sur des objets C#, ce qui permet de réduire le code de base et d'améliorer la lisibilité du code.
5. Requêtes paramétrées : Dapper prend en charge les requêtes paramétrées, ce qui permet de se protéger contre les attaques par injection SQL et d'améliorer les performances.
6. Multi-Mapping : Dapper gère de manière transparente les relations de type "un à plusieurs" et "plusieurs à plusieurs", ce qui permet d'exécuter efficacement des requêtes multiples et de simplifier ainsi la recherche de données complexes.

Accès asynchrone aux données avec Dapper

Dapper propose des méthodes d'extension asynchrones qui reflètent ses homologues synchrones, ce qui permet aux développeurs d'exécuter des requêtes de base de données de manière asynchrone. Ces méthodes asynchrones sont idéales pour les opérations liées aux E/S, telles que les requêtes de base de données, où le thread principal peut continuer à exécuter d'autres tâches en attendant que l'opération de base de données se termine.

Méthodes asynchrones clés dans Dapper

1. QueryAsync : Exécute une requête SQL de manière asynchrone et renvoie le résultat sous la forme d'une séquence d'objets dynamiques ou d'objets fortement typés.
2. QueryFirstOrDefaultAsync : Exécute une requête SQL de manière asynchrone et renvoie le premier résultat ou une valeur par défaut si aucun résultat n'est trouvé.

3. ExecuteAsync : Exécute une commande SQL de manière asynchrone (par exemple, INSERT, UPDATE, DELETE) et renvoie le nombre de lignes concernées.

   Configuration de l'environnement : Avant de vous plonger dans les exemples de code, assurez-vous que vous avez installé les outils nécessaires :

4. Visual Studio ou Visual Studio Code.
5. .NET SDK.

6. Paquet SQLite pour .NET.

   Pour installer le paquetage SQLite, exécutez la commande suivante dans le répertoire de votre projet :

dotnet add package Microsoft.Data.Sqlite

Création d'une base de données SQLite : À des fins de démonstration, créons un simple fichier de base de données SQLite nommé "exemple.db" avec une table "Utilisateurs" contenant les colonnes "Id", "Nom" et "Email"

CREATE TABLE Users (
    Id INTEGER PRIMARY KEY,
    Name TEXT,
    Email TEXT
);

CREATE TABLE Users (
    Id INTEGER PRIMARY KEY,
    Name TEXT,
    Email TEXT
);

CREATE TABLE Users(Id [INTEGER] PRIMARY KEY, Name TEXT, Email TEXT)

Utilisation de Dapper avec SQLite

1. Tout d'abord, assurez-vous que vous avez importé les espaces de noms nécessaires :

using Microsoft.Data.Sqlite;
using Dapper;

using Microsoft.Data.Sqlite;
using Dapper;

Imports Microsoft.Data.Sqlite
Imports Dapper

1. Établir une connexion à la base de données SQLite :

    string connectionString = "Data Source=example.db"; // SQLite database 
    connection string
    using (var connection = new SqliteConnection(connectionString))
    {
        connection.Open();
        // Your Dapper queries will go here
    }

    string connectionString = "Data Source=example.db"; // SQLite database 
    connection string
    using (var connection = new SqliteConnection(connectionString))
    {
        connection.Open();
        // Your Dapper queries will go here
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

2. Exécuter une requête avec Dapper :

    // Define a class to represent the structure of a user
    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
    }
    // Query to select all users or default value
    string query = "SELECT * FROM Users"; // var sql queries
    var users = connection.Query<User>(query).ToList();
    // Display the results
    foreach (var user in users)
    {
        Console.WriteLine($"Id: {user.Id}, Name: {user.Name}, Email: {user.Email}");
    }

    // Define a class to represent the structure of a user
    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
    }
    // Query to select all users or default value
    string query = "SELECT * FROM Users"; // var sql queries
    var users = connection.Query<User>(query).ToList();
    // Display the results
    foreach (var user in users)
    {
        Console.WriteLine($"Id: {user.Id}, Name: {user.Name}, Email: {user.Email}");
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

3. Insérer des données dans la base de données à l'aide de Dapper :

    // Define a new user 
    var newUser = new User { Name = "John Doe", Email = "john@example.com" };
    // user generated SQL query/stored procedure to insert a new user
    string insertQuery = "INSERT INTO Users (Name, Email) VALUES (@Name, @Email)";
    // Execute the query
    connection.Execute(insertQuery, newUser);

    // Define a new user 
    var newUser = new User { Name = "John Doe", Email = "john@example.com" };
    // user generated SQL query/stored procedure to insert a new user
    string insertQuery = "INSERT INTO Users (Name, Email) VALUES (@Name, @Email)";
    // Execute the query
    connection.Execute(insertQuery, newUser);

IRON VB CONVERTER ERROR developers@ironsoftware.com

Présentation d'IronPDF

IronPDF est une bibliothèque C# de Iron Software qui permet aux développeurs de créer, d'éditer et de manipuler des documents PDF par programmation dans des applications .NET. Il offre des fonctionnalités telles que la génération de documents PDF à partir de HTML, d'images et d'autres formats, ainsi que l'ajout de texte, d'images et de divers éléments à des fichiers PDF existants. IronPDF vise à simplifier les tâches de génération et de manipulation de fichiers PDF pour les développeurs .NET en fournissant un ensemble complet d'outils et d'API.

IronPDF offre une série de fonctionnalités pour la génération et la manipulation de fichiers PDF au sein des applications .NET :

1. Conversion de HTML en PDF : Convertir le contenu HTML, y compris les styles CSS, en documents PDF.
2. Conversion d'images en PDF : Conversion d'images (tels que JPEG, PNG, BMP) vers des documents PDF.
3. Conversion de texte en PDF : Conversion de texte simple ou de texte formaté (RTF) vers des documents PDF.
4. Génération de PDF : Créez des documents PDF à partir de zéro par programmation.
5. Édition de PDF : Modifiez des documents PDF existants en ajoutant ou en modifiant du texte, des images et d'autres éléments.
6. Fusion et division de PDF : Combinez plusieurs documents PDF en un seul document ou divisez un document PDF en plusieurs fichiers.
7. Sécurité PDF : Appliquez une protection par mot de passe et un cryptage aux documents PDF afin d'en restreindre l'accès et de protéger les informations sensibles.
8. Remplissage de formulaires PDF : Remplir des formulaires PDF avec des données de manière programmatique.
9. Impression PDF : Imprimez des documents PDF directement à partir de votre application .NET.
10. Paramètres de conversion PDF : Personnalisez divers paramètres tels que la taille des pages, l'orientation, les marges, la compression, etc. lors de la génération du PDF.
11. Extraction de texte PDF : Extraire le contenu textuel des documents PDF en vue d'un traitement ou d'une analyse ultérieurs.
12. Métadonnées PDF : Définir les métadonnées (auteur, titre, sujet, mots-clés) pour les documents PDF.

Générer des documents PDF avec IronPDF et Dapper

Créer une application console dans Visual Studio

Indiquer le nom et la localisation du projet

Sélectionner la version .NET

Installez les paquets suivants à partir du gestionnaire de paquets de Visual Studio ou de la console

dotnet add package Microsoft.Data.Sqlite

dotnet add package Dapper --version 2.1.35

dotnet add package IronPdf --version 2024.4.2

dotnet add package IronPdf --version 2024.4.2

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf --version 2024.4.2

Utilisez le code ci-dessous pour générer un document PDF

using Dapper;
using IronPdf;
using Microsoft.Data.Sqlite;
string connectionString = "Data Source=ironPdf.db"; // sql server database connection string
var content = "<h1>Demonstrate IronPDF with Dapper</h1>";
content += "<h2>Create a new database using Microsoft.Data.Sqlite</h2>";
content += "<p>new SqliteConnection(connectionString) and connection.Open()</p>";
using (var connection = new SqliteConnection(connectionString))
{
    connection.Open();
    content += "<h2>Create a Users Table using dapper and insert sql query</h2>";
    content += "<p>CREATE TABLE IF NOT EXISTS Users</p>";
    // create table
    string sql = "CREATE TABLE IF NOT EXISTS Users (\n    Id INTEGER PRIMARY KEY,\n    Name TEXT,\n    Email TEXT\n);";
    connection.Execute(sql);
    content += "<h2>Add Users to table using Dapper</h2>";
    content += AddUser(connection, new User { Name = "John Doe", Email = "john@example.com" });
    content += AddUser(connection, new User { Name = "Smith William", Email = "Smith@example.com" });
    content += AddUser(connection, new User { Name = "Rock Bill", Email = "Rock@example.com" });
    content += AddUser(connection, new User { Name = "Jack Sparrow", Email = "Jack@example.com" });
    content += AddUser(connection, new User { Name = "Tomus Tibe", Email = "Tomus@example.com" });
    content += "<h2>Get Users From table using Dapper</h2>";
    // Query to select all users or default value
    string query = "SELECT * FROM Users"; // var sql queries
    var users = connection.Query<User>(query).ToList();
    foreach (var user in users)
    {
        content += $"<p>Id:{user.Id}, Name:{user.Name}, email: {user.Email}</p>";
        Console.WriteLine($"{user.Id}. User Name:{user.Name}, Email:{user.Email}");
    }
    // create Renderer
    var renderer = new ChromePdfRenderer();
    // Create a PDF from HTML string
    var pdf = renderer.RenderHtmlAsPdf(content);
    // Save to a file or Stream
    pdf.SaveAs("dapper.pdf");
}
string AddUser(SqliteConnection sqliteConnection, User user)
{
    // user generated SQL query/stored procedure to insert a new user
    string insertQuery = "INSERT INTO Users (Name, Email) VALUES (@Name, @Email)";
    // Execute the query
    sqliteConnection.Execute(insertQuery, user);
    return $"<p>Name:{user.Name}, email: {user.Email}</p>"; 
}

using Dapper;
using IronPdf;
using Microsoft.Data.Sqlite;
string connectionString = "Data Source=ironPdf.db"; // sql server database connection string
var content = "<h1>Demonstrate IronPDF with Dapper</h1>";
content += "<h2>Create a new database using Microsoft.Data.Sqlite</h2>";
content += "<p>new SqliteConnection(connectionString) and connection.Open()</p>";
using (var connection = new SqliteConnection(connectionString))
{
    connection.Open();
    content += "<h2>Create a Users Table using dapper and insert sql query</h2>";
    content += "<p>CREATE TABLE IF NOT EXISTS Users</p>";
    // create table
    string sql = "CREATE TABLE IF NOT EXISTS Users (\n    Id INTEGER PRIMARY KEY,\n    Name TEXT,\n    Email TEXT\n);";
    connection.Execute(sql);
    content += "<h2>Add Users to table using Dapper</h2>";
    content += AddUser(connection, new User { Name = "John Doe", Email = "john@example.com" });
    content += AddUser(connection, new User { Name = "Smith William", Email = "Smith@example.com" });
    content += AddUser(connection, new User { Name = "Rock Bill", Email = "Rock@example.com" });
    content += AddUser(connection, new User { Name = "Jack Sparrow", Email = "Jack@example.com" });
    content += AddUser(connection, new User { Name = "Tomus Tibe", Email = "Tomus@example.com" });
    content += "<h2>Get Users From table using Dapper</h2>";
    // Query to select all users or default value
    string query = "SELECT * FROM Users"; // var sql queries
    var users = connection.Query<User>(query).ToList();
    foreach (var user in users)
    {
        content += $"<p>Id:{user.Id}, Name:{user.Name}, email: {user.Email}</p>";
        Console.WriteLine($"{user.Id}. User Name:{user.Name}, Email:{user.Email}");
    }
    // create Renderer
    var renderer = new ChromePdfRenderer();
    // Create a PDF from HTML string
    var pdf = renderer.RenderHtmlAsPdf(content);
    // Save to a file or Stream
    pdf.SaveAs("dapper.pdf");
}
string AddUser(SqliteConnection sqliteConnection, User user)
{
    // user generated SQL query/stored procedure to insert a new user
    string insertQuery = "INSERT INTO Users (Name, Email) VALUES (@Name, @Email)";
    // Execute the query
    sqliteConnection.Execute(insertQuery, user);
    return $"<p>Name:{user.Name}, email: {user.Email}</p>"; 
}

Imports Microsoft.VisualBasic
Imports Dapper
Imports IronPdf
Imports Microsoft.Data.Sqlite
Private connectionString As String = "Data Source=ironPdf.db" ' sql server database connection string
Private content = "<h1>Demonstrate IronPDF with Dapper</h1>"
Private content &= "<h2>Create a new database using Microsoft.Data.Sqlite</h2>"
Private content &= "<p>new SqliteConnection(connectionString) and connection.Open()</p>"
Using connection = New SqliteConnection(connectionString)
	connection.Open()
	content &= "<h2>Create a Users Table using dapper and insert sql query</h2>"
	content &= "<p>CREATE TABLE IF NOT EXISTS Users</p>"
	' create table
	Dim sql As String = "CREATE TABLE IF NOT EXISTS Users (" & vbLf & "    Id INTEGER PRIMARY KEY," & vbLf & "    Name TEXT," & vbLf & "    Email TEXT" & vbLf & ");"
	connection.Execute(sql)
	content &= "<h2>Add Users to table using Dapper</h2>"
	content += AddUser(connection, New User With {
		.Name = "John Doe",
		.Email = "john@example.com"
	})
	content += AddUser(connection, New User With {
		.Name = "Smith William",
		.Email = "Smith@example.com"
	})
	content += AddUser(connection, New User With {
		.Name = "Rock Bill",
		.Email = "Rock@example.com"
	})
	content += AddUser(connection, New User With {
		.Name = "Jack Sparrow",
		.Email = "Jack@example.com"
	})
	content += AddUser(connection, New User With {
		.Name = "Tomus Tibe",
		.Email = "Tomus@example.com"
	})
	content &= "<h2>Get Users From table using Dapper</h2>"
	' Query to select all users or default value
	Dim query As String = "SELECT * FROM Users" ' var sql queries
	Dim users = connection.Query(Of User)(query).ToList()
	For Each user In users
		content += $"<p>Id:{user.Id}, Name:{user.Name}, email: {user.Email}</p>"
		Console.WriteLine($"{user.Id}. User Name:{user.Name}, Email:{user.Email}")
	Next user
	' create Renderer
	Dim renderer = New ChromePdfRenderer()
	' Create a PDF from HTML string
	Dim pdf = renderer.RenderHtmlAsPdf(content)
	' Save to a file or Stream
	pdf.SaveAs("dapper.pdf")
End Using
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'string AddUser(SqliteConnection sqliteConnection, User user)
'{
'	' user generated SQL query/stored procedure to insert a new user
'	string insertQuery = "INSERT INTO Users (Name, Email) VALUES (@Name, @Email)";
'	' Execute the query
'	sqliteConnection.Execute(insertQuery, user);
'	Return string.Format("<p>Name:{0}, email: {1}</p>", user.Name, user.Email);
'}

Explication du code

1. Commencez par créer un détenteur de contenu de chaîne pour la génération de PDF
2. Créer une nouvelle base de données en utilisant Microsoft.Data.Sqlite, connection.Open()` créera une base de données vide
3. Créer une table d'utilisateurs à l'aide de Dapper et insérer une requête SQL
4. Ajouter des utilisateurs à une table en utilisant Dapper avec des requêtes d'insertion
5. Requête pour sélectionner tous les utilisateurs ou la valeur par défaut
6. Enregistrer le contenu généré au format PDF en utilisant les méthodes ChromePdfRenderer et SaveAs

Sortie

Licence (Essai disponible pour IronPDF)

IronPDF.

Une licence d'essai pour les développeurs peut être obtenue ici.

Veuillez remplacer la clé dans le fichier appSettings.json comme indiqué ci-dessous

{
  "IronPdf.License.LicenseKey" : "The Key Goes Here"
}

{
  "IronPdf.License.LicenseKey" : "The Key Goes Here"
}

If True Then
  "IronPdf.License.LicenseKey" : "The Key Goes Here"
End If

Conclusion

Dapper simplifie l'accès aux données dans les applications .NET et, combiné à SQLite, il constitue une solution légère et efficace pour la gestion des bases de données. En suivant les étapes décrites dans cet article, vous pouvez utiliser Dapper pour interagir avec les bases de données SQLite de manière transparente, ce qui vous permettra de créer facilement des applications robustes et évolutives. Avec IronPDF, les développeurs peuvent acquérir des compétences liées aux bases de données ORM comme Dapper et aux bibliothèques de génération de PDF comme IronPDF.