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. Dapper, ein leichtgewichtiger Object-Relational Mapper (ORM) für .NET, bietet einen optimierten Ansatz für die Datenbankinteraktion. In diesem Artikel wird die Verwendung von Dapper C# mit einer SQLite-Datenbankdatei untersucht, wobei die Einfachheit und Effektivität anhand von Codebeispielen demonstriert wird. Zusätzlich werde ich die bemerkenswerte PDF-Generierungsbibliothek namens IronPDF von Iron Software vorstellen.

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 bekannt für seine ausgezeichnete Leistung aufgrund seines leichten Designs und der effizienten Objektzuordnung.

2. Einfachheit: Die API von Dapper ist minimalistisch und intuitiv, was es Entwicklern erleichtert, sie zu verstehen und effektiv zu nutzen.

3. Unterstützung für Roh-SQL: Dapper ermöglicht es Entwicklern, Roh-SQL-Abfragen zu schreiben, um die volle Kontrolle über Datenbankinteraktionen zu haben.

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

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

6. Multi-Mapping: Dapper verarbeitet nahtlos Eins-zu-Viele- und Viele-zu-Viele-Beziehungen, indem es ermöglicht, mehrere Abfragen effizient auszuführen, was die komplexe Datenabfrage 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 Sequenz 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, falls 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

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
    }

Dim connectionString As String = "Data Source=example.db" ' SQLite database connection string
	Using connection = New SqliteConnection(connectionString)
		connection.Open()
		' Your Dapper queries will go here
	End Using

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 Entwicklern ermöglicht, PDF-Dokumente programmatisch innerhalb von .NET-Anwendungen 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. Bild-zu-PDF-Konvertierung: Konvertieren Sie Bilder (wie JPEG, PNG, BMP) in PDF-Dokumente.

3. Text-zu-PDF-Konvertierung: Konvertieren Sie einfachen Text oder formatierten Text (RTF) in PDF-Dokumente.

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: Legen Sie Metadaten (Autor, Titel, Thema, Schlüsselwörter) für PDF-Dokumente fest.

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 Microsoft.Data.Sqlite

dotnet add package Dapper --version 2.1.35

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, connection.Open() wird eine leere Datenbank erstellen

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 generierten Inhalt als PDF mit den Methoden ChromePdfRenderer und SaveAs

Ausgabe

Lizenz (Testversion für IronPDF verfügbar)

Die Lizenzinformationen von IronPDF sind verfügbar, um die Einhaltung und Nutzung innerhalb Ihres Projekts sicherzustellen.

Eine Testlizenz für Entwickler kann über die IronPDF-Testlizenzseite bezogen werden.

Bitte ersetzen Sie den Schlüssel in der appSettings.json-Datei, die unten gezeigt wird

{
  "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 in Bezug auf ORM-Datenbanken wie Dapper und PDF-Erzeugungsbibliotheken wie IronPDF erwerben.