Dapper C# (Wie es für Entwickler funktioniert)

Einführung

In der modernen Softwareentwicklung ist der effiziente Zugriff auf Datenbanken entscheidend für die Leistung und Skalierbarkeit von Anwendungen. Dapperein leichtgewichtiger objektrelationaler Mapper (ORM) für .NET, bietet einen rationalisierten Ansatz für die Interaktion mit Datenbanken. In diesem Artikel erfahren Sie, wie Sie Dapper C mit einer SQLite-Datenbankdatei verwenden können, und wir demonstrieren seine Einfachheit und Effektivität anhand von Codebeispielen. Außerdem werde ich die bemerkenswerte PDF-Erzeugungsbibliothek namens IronPDF von Iron Software.

Was ist Dapper?

Dapper ist ein objekt-relationales Mapping (ORM) framework für die .NET-Plattform. Es handelt sich um einen einfachen Objekt-Mapper, mit dem Sie ein objektorientiertes Domänenmodell auf eine traditionelle relationale Datenbank abbilden können. Dapper ist für seine Geschwindigkeit und Leistung bekannt und wird oft als "King of Micro ORM" bezeichnet Es erreicht die Geschwindigkeit eines ADO.NET-Datenlesers und erweitert die IDbConnection-Schnittstelle um nützliche Erweiterungsmethoden zur Abfrage von SQL-Datenbanken.

Hauptmerkmale von Dapper

1. Leistung: Dapper ist für seine hervorragende Leistung bekannt, die auf sein leichtgewichtiges Design und seine effiziente Objektzuordnung zurückzuführen ist.

2. Einfachheit: Die API von Dapper ist minimalistisch und intuitiv, so dass sie für Entwickler leicht zu verstehen und effektiv zu nutzen ist.

3. Roh-SQL-Unterstützung: Dapper ermöglicht Entwicklern das Schreiben von Roh-SQL-Abfragen und damit die volle Kontrolle über Datenbankinteraktionen.

4. Objektzuordnung: Dapper ordnet Abfrageergebnisse direkt C#-Objekten zu, wodurch die Anzahl der Kodiervorlagen reduziert und die Lesbarkeit des Codes verbessert wird.

5. Parametrisierte Abfragen: Dapper unterstützt parametrisierte Abfragen, die vor SQL-Injection-Angriffen schützen und die Leistung verbessern.

6. Multi-Mapping: Dapper verarbeitet nahtlos One-to-Many- und Many-to-Many-Beziehungen, so dass mehrere Abfragen effizient ausgeführt werden können, was den komplexen Datenabruf vereinfacht.

Asynchroner Datenzugriff mit Dapper

Dapper bietet asynchrone Erweiterungsmethoden, die die synchronen Gegenstücke widerspiegeln und es Entwicklern ermöglichen, Datenbankabfragen asynchron auszuführen. Diese asynchronen Methoden sind ideal für E/A-gebundene Operationen, wie z. B. Datenbankabfragen, bei denen der Hauptthread mit der Ausführung anderer Aufgaben fortfahren kann, während er auf den Abschluss der Datenbankoperation wartet.

Wichtige asynchrone Methoden in Dapper

1. QueryAsync: Führt eine SQL-Abfrage asynchron aus und gibt das Ergebnis als eine Folge von dynamischen Objekten oder stark typisierten Objekten zurück.

2. QueryFirstOrDefaultAsync: Führt eine SQL-Abfrage asynchron aus und gibt das erste Ergebnis oder einen Standardwert zurück, wenn kein Ergebnis gefunden wird.

3. ExecuteAsync: Führt einen SQL-Befehl asynchron aus (z.B. INSERT, UPDATE, DELETE) und gibt die Anzahl der betroffenen Zeilen zurück.

   Einrichten der Umgebung: Bevor Sie sich mit den Codebeispielen befassen, sollten Sie sicherstellen, dass Sie die erforderlichen Tools installiert haben:

4. Visual Studio oder Visual Studio Code.

5. .NET SDK.

6. SQLite-Paket für .NET.

   Um das SQLite-Paket zu installieren, führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus:

dotnet add package Microsoft.Data.Sqlite

Erstellen einer SQLite-Datenbank: Zu Demonstrationszwecken erstellen wir eine einfache SQLite-Datenbankdatei mit dem Namen "example.db" mit einer Tabelle "Users", die Spalten für "Id", "Name" und "Email" enthält

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)

Verwendung von Dapper mit SQLite

1. Stellen Sie zunächst sicher, dass Sie die erforderlichen Namespaces importiert haben:

using Microsoft.Data.Sqlite;
using Dapper;

using Microsoft.Data.Sqlite;
using Dapper;

Imports Microsoft.Data.Sqlite
Imports Dapper

1. Stellen Sie eine Verbindung zur SQLite-Datenbank her:

    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. Führen Sie eine Abfrage mit Dapper aus:

    // 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. Einfügen von Daten in die Datenbank mit 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

Einführung in IronPDF

IronPDF ist eine C#-Bibliothek von Iron Software die es Entwicklern ermöglicht, PDF-Dokumente innerhalb von .NET-Anwendungen programmatisch zu erstellen, zu bearbeiten und zu manipulieren. Es bietet Funktionen wie die Erstellung von PDF-Dokumenten aus HTML, Bildern und anderen Formaten sowie das Hinzufügen von Text, Bildern und verschiedenen Elementen zu bestehenden PDF-Dateien. IronPDF zielt darauf ab, die PDF-Erzeugung und -Bearbeitung für .NET-Entwickler zu vereinfachen, indem es einen umfassenden Satz von Tools und APIs bereitstellt.

IronPDF bietet eine Reihe von Funktionen für die PDF-Erzeugung und -Bearbeitung in .NET-Anwendungen:

1. Konvertierung von HTML in PDF: Konvertieren Sie HTML-Inhalte, einschließlich CSS-Stile, in PDF-Dokumente.

2. Konvertierung von Bildern in PDF: Bilder konvertieren (wie z. B. JPEG, PNG, BMP) zu PDF-Dokumenten.

3. Konvertierung von Text in PDF: Konvertieren von einfachem Text oder formatiertem Text (RTF) zu PDF-Dokumenten.

4. PDF-Erzeugung: Erstellen Sie PDF-Dokumente von Grund auf programmatisch.

5. PDF-Bearbeitung: Bearbeiten Sie vorhandene PDF-Dokumente durch Hinzufügen oder Ändern von Text, Bildern und anderen Elementen.

6. PDF zusammenführen und aufteilen: Kombinieren Sie mehrere PDF-Dokumente zu einem einzigen Dokument, oder teilen Sie ein PDF-Dokument in mehrere Dateien auf.

7. PDF-Sicherheit: Wenden Sie Passwortschutz und Verschlüsselung auf PDF-Dokumente an, um den Zugriff zu beschränken und sensible Informationen zu schützen.

8. PDF-Formular ausfüllen: Füllen Sie PDF-Formulare programmgesteuert mit Daten aus.

9. PDF-Druck: Drucken Sie PDF-Dokumente direkt aus Ihrer .NET-Anwendung.

10. PDF-Konvertierungseinstellungen: Passen Sie verschiedene Einstellungen wie Seitengröße, Ausrichtung, Ränder, Komprimierung und mehr während der PDF-Erstellung an.

11. PDF-Text-Extraktion: Extrahieren Sie Textinhalte aus PDF-Dokumenten zur weiteren Verarbeitung oder Analyse.

12. PDF-Metadaten: Metadaten festlegen (autor, Titel, Thema, Schlüsselwörter) für PDF-Dokumente.

Generierung von PDF-Dokumenten mit IronPDF und Dapper

Erstellen einer Konsolenanwendung in Visual Studio

Geben Sie den Projektnamen und den Standort an

.NET-Version auswählen

Installieren Sie die folgenden Pakete entweder über den Visual Studio Package Manager oder die Konsole

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

Verwenden Sie den folgenden Code, um ein PDF-Dokument zu erzeugen

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);
'}

Code Erläuterung

1. Beginnen Sie mit der Erstellung eines String-Inhaltshalters für die PDF-Generierung

2. Erstellen Sie eine neue Datenbank mit "Microsoft.Data.Sqlite", "Verbindung.Öffnen()` erstellt eine leere db

3. Erstellen einer Benutzertabelle mit Dapper und Einfügen einer SQL-Abfrage

4. Hinzufügen von Benutzern zur Tabelle mit Dapper mit Insert-Abfragen

5. Abfrage zur Auswahl aller Benutzer oder Standardwert

6. Speichern Sie den erzeugten Inhalt als PDF mit den Methoden "ChromePdfRenderer" und "SaveAs"

Ausgabe

Lizenz (Testversion verfügbar für IronPDF)

IronPDF.

Eine Testlizenz für Entwickler kann erworben werden hier.

Bitte ersetzen Sie den Schlüssel in der Datei appSettings.json wie folgt

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

Schlussfolgerung

Dapper vereinfacht den Datenzugriff in .NET-Anwendungen und bietet in Kombination mit SQLite eine schlanke und effiziente Lösung für die Verwaltung von Datenbanken. Wenn Sie die in diesem Artikel beschriebenen Schritte befolgen, können Sie Dapper nutzen, um nahtlos mit SQLite-Datenbanken zu interagieren, so dass Sie problemlos robuste und skalierbare Anwendungen erstellen können. Zusammen mit IronPDF können Entwickler Kenntnisse im Zusammenhang mit ORM-Datenbanken wie Dapper und PDF-Erzeugungsbibliotheken wie IronPDF erwerben.