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

NHibernate ist ein leistungsfähiges Object Relational Mapping(ORM) framework, das für die Verwendung mit dem .NET-Framework entwickelt wurde. Es bietet Entwicklern eine effiziente Möglichkeit, die Lücke zwischen der objektorientierten Welt von .NET-Anwendungen und der relationalen Welt von Datenbanken zu schließen. Durch den Einsatz von NHibernate können Sie die Menge an Boilerplate-Code, der für die Implementierung von Datenzugriffsschichten erforderlich ist, erheblich reduzieren, wodurch Ihre .NET-Anwendungen sauberer und wartbarer werden.

Die Rolle von ORM bei der Vereinfachung von Datenbankinteraktionen

ORM-Frameworks wie NHibernate vereinfachen die Interaktion mit relationalen Datenbanken, indem sie es Entwicklern ermöglichen, mit Daten in Form von Objekten und deren Eigenschaften zu arbeiten, anstatt mit SQL-Anweisungen. Diese Abstraktion hilft Entwicklern, sich mehr auf die Geschäftslogik ihrer Anwendungen zu konzentrieren und weniger auf die zugrunde liegenden SQL-Befehle und das Datenbankschema. NHibernate übernimmt zum Beispiel die gesamte SQL-Generierung und -Ausführung, so dass Operationen wie Einfügungen, Löschungen und Aktualisierungen mit einfacher Objektkonvertierung und Objektmanipulation durchgeführt werden können.

Einrichten von NHibernate in einem .NET-Projekt

Um mit NHibernate in Ihrem .NET-Projekt zu beginnen, müssen Sie zunächst das NHibernate-Paket installieren. Dies kann einfach über den NuGet Package Manager von Visual Studio mit dem folgenden Befehl erfolgen:

Install-Package IronPdf

NHibernate mit XML-Konfigurationsdatei konfigurieren

Sobald NHibernate installiert ist, muss es im nächsten Schritt konfiguriert werden. Dazu muss eine Hibernate-Mapping-Datei erstellt werden, die die Einstellungen Ihres Datenbankservers und die Zuordnungsdetails Ihrer Objekte zu den Datenbanktabellen enthält. Die Haupt-XML-Datei, die in der Regel den Namen "hibernate.cfg.xml" trägt, enthält Einstellungen wie die Datenbankverbindungszeichenfolge, den Dialekt und andere datenbankspezifische Einstellungen.

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">
  <session-factory>
    <property name="connection.provider">NHibernate.Connection.DriverConnectionProvider</property>
    <property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>
    <property name="connection.connection_string">
      Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;
    </property>
    <property name="dialect">NHibernate.Dialect.MsSql2012Dialect</property>
    <property name="show_sql">true</property>
    <mapping resource="Employee.hbm.xml"/>
  </session-factory>
</hibernate-configuration>

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">
  <session-factory>
    <property name="connection.provider">NHibernate.Connection.DriverConnectionProvider</property>
    <property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>
    <property name="connection.connection_string">
      Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;
    </property>
    <property name="dialect">NHibernate.Dialect.MsSql2012Dialect</property>
    <property name="show_sql">true</property>
    <mapping resource="Employee.hbm.xml"/>
  </session-factory>
</hibernate-configuration>

Verständnis der Kernkomponenten von NHibernate

Eine der Schlüsselkomponenten in NHibernate ist die Session Factory, die nach dem Factory Design Pattern entworfen wurde. Diese Komponente erstellt Session-Objekte, die die Verbindung zur Datenbank verwalten und die Transaktionsoperationen durchführen. Die Erstellung der Session Factory ist kostspielig und wird daher in der Regel nur einmal pro Lebenszeit der Anwendung durchgeführt, was sie zu einem entscheidenden Element für die Leistungsoptimierung macht.

Wichtige Klassen und Methoden in NHibernate

NHibernate besteht aus mehreren wesentlichen Klassen und Methoden. So spielt beispielsweise die Schnittstelle "ISession" eine grundlegende Rolle in NHibernate, da sie die Erstellung von Datenabfrage- und -bearbeitungssitzungen erleichtert. Methoden wie OpenSession helfen Entwicklern, Transaktionen zu starten, SQL-Befehle auszuführen und die Datenbank entweder mit SQL-Anweisungen oder NHibernate's eigener HQL abzufragen(Hibernate Abfragesprache).

Mapping von Entitäten auf Datenbanktabellen mit NHibernate

Das Entity-Mapping in NHibernate wird über Mapping-Dateien realisiert, die in der Regel in XML geschrieben sind. Diese Dateien, oft benannt nach der Entitätsklasse(z. B. Mitarbeiter.hbm.xml)definieren, wie die Eigenschaften einer Entität auf die Spalten einer Datenbanktabelle abgebildet werden. Eine typische Mapping-Datei enthält den Klassennamen, den Tabellennamen und Details zu jeder Eigenschaft, einschließlich Primärschlüssel, Spaltenname und Datentyp.

Detaillierter Blick auf die in Mapping-Dateien verwendeten Eigenschaften und Attribute

In diesen Mapping-Dateien können Sie verschiedene Attribute für jede Eigenschaft angeben, z. B. Nicht-Null-Beschränkungen oder eindeutige Beschränkungen. NHibernate ermöglicht auch komplexe Mappings wie One-to-Many- und Many-to-One-Beziehungen und bietet damit ein leistungsfähiges Toolset für die Darstellung relationaler Datenstrukturen innerhalb eines objektorientierten Frameworks.

Ausführen von SQL-Befehlen und -Transaktionen in NHibernate

NHibernate vereinfacht CRUD(Erstellen, Lesen, Aktualisieren, Löschen) operationen durch Abstraktion der zugrunde liegenden SQL-Befehle. Entwickler können diese Operationen durchführen, ohne expliziten SQL-Code zu schreiben, und stattdessen Methoden verwenden, die von der Schnittstelle "ISession" bereitgestellt werden. Um beispielsweise eine neue Entität zur Datenbank hinzuzufügen, erstellen Sie einfach eine neue Instanz des Objekts, legen seine Eigenschaften fest und verwenden die Methode Save der ISession.

Verwaltung von Transaktionen mit ITransaction

Transaktionen werden in NHibernate über die Schnittstelle ITransaction verwaltet, die Datenintegrität und -konsistenz gewährleistet. Mit der Methode BeginTransaction von ISession können Entwickler sicherstellen, dass alle Operationen erfolgreich abgeschlossen sind, bevor die Daten in die Datenbank übertragen werden, oder ein Rollback durchführen, wenn etwas schief geht, und so die Stabilität Ihrer Daten aufrechterhalten.

Vollständiges Code-Beispiel

Dieses Beispiel umfasst die Einrichtung der NHibernate-Konfigurations- und Mapping-Dateien und demonstriert, wie mit NHibernate Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge durchgeführt werden.

using NHibernate;
using NHibernate.Cfg;
using System;
public class Employee
{
    public virtual int Id { get; set; }
    public virtual string FirstName { get; set; }
    public virtual string LastName { get; set; }
}
class Program
{
    private static ISessionFactory sessionFactory;
    static void Main()
    {
        sessionFactory = new Configuration().Configure().BuildSessionFactory();
        CreateEmployee();
        ReadEmployee(1);
        UpdateEmployee(1, "UpdatedName");
        DeleteEmployee(1);
    }
    static void CreateEmployee()
    {
        using (var session = sessionFactory.OpenSession())
        using (var transaction = session.BeginTransaction())
        {
            var newEmployee = new Employee
            {
                FirstName = "Iron",
                LastName = "Software"
            };
            session.Save(newEmployee);
            transaction.Commit();
            Console.WriteLine("Employee created: " + newEmployee.Id);
        }
    }
    static void ReadEmployee(int id)
    {
        using (var session = sessionFactory.OpenSession())
        {
            var employee = session.Get<Employee>(id);
            Console.WriteLine("Read Employee: " + employee.FirstName + " " + employee.LastName);
        }
    }
    static void UpdateEmployee(int id, string newFirstName)
    {
        using (var session = sessionFactory.OpenSession())
        using (var transaction = session.BeginTransaction())
        {
            var employee = session.Get<Employee>(id);
            employee.FirstName = newFirstName;
            session.Update(employee);
            transaction.Commit();
            Console.WriteLine("Employee updated: " + employee.FirstName);
        }
    }
    static void DeleteEmployee(int id)
    {
        using (var session = sessionFactory.OpenSession())
        using (var transaction = session.BeginTransaction())
        {
            var employee = session.Get<Employee>(id);
            session.Delete(employee);
            transaction.Commit();
            Console.WriteLine("Employee deleted");
        }
    }
}

using NHibernate;
using NHibernate.Cfg;
using System;
public class Employee
{
    public virtual int Id { get; set; }
    public virtual string FirstName { get; set; }
    public virtual string LastName { get; set; }
}
class Program
{
    private static ISessionFactory sessionFactory;
    static void Main()
    {
        sessionFactory = new Configuration().Configure().BuildSessionFactory();
        CreateEmployee();
        ReadEmployee(1);
        UpdateEmployee(1, "UpdatedName");
        DeleteEmployee(1);
    }
    static void CreateEmployee()
    {
        using (var session = sessionFactory.OpenSession())
        using (var transaction = session.BeginTransaction())
        {
            var newEmployee = new Employee
            {
                FirstName = "Iron",
                LastName = "Software"
            };
            session.Save(newEmployee);
            transaction.Commit();
            Console.WriteLine("Employee created: " + newEmployee.Id);
        }
    }
    static void ReadEmployee(int id)
    {
        using (var session = sessionFactory.OpenSession())
        {
            var employee = session.Get<Employee>(id);
            Console.WriteLine("Read Employee: " + employee.FirstName + " " + employee.LastName);
        }
    }
    static void UpdateEmployee(int id, string newFirstName)
    {
        using (var session = sessionFactory.OpenSession())
        using (var transaction = session.BeginTransaction())
        {
            var employee = session.Get<Employee>(id);
            employee.FirstName = newFirstName;
            session.Update(employee);
            transaction.Commit();
            Console.WriteLine("Employee updated: " + employee.FirstName);
        }
    }
    static void DeleteEmployee(int id)
    {
        using (var session = sessionFactory.OpenSession())
        using (var transaction = session.BeginTransaction())
        {
            var employee = session.Get<Employee>(id);
            session.Delete(employee);
            transaction.Commit();
            Console.WriteLine("Employee deleted");
        }
    }
}

Imports NHibernate
Imports NHibernate.Cfg
Imports System
Public Class Employee
	Public Overridable Property Id() As Integer
	Public Overridable Property FirstName() As String
	Public Overridable Property LastName() As String
End Class
Friend Class Program
	Private Shared sessionFactory As ISessionFactory
	Shared Sub Main()
		sessionFactory = (New Configuration()).Configure().BuildSessionFactory()
		CreateEmployee()
		ReadEmployee(1)
		UpdateEmployee(1, "UpdatedName")
		DeleteEmployee(1)
	End Sub
	Private Shared Sub CreateEmployee()
		Using session = sessionFactory.OpenSession()
		Using transaction = session.BeginTransaction()
			Dim newEmployee = New Employee With {
				.FirstName = "Iron",
				.LastName = "Software"
			}
			session.Save(newEmployee)
			transaction.Commit()
			Console.WriteLine("Employee created: " & newEmployee.Id)
		End Using
		End Using
	End Sub
	Private Shared Sub ReadEmployee(ByVal id As Integer)
		Using session = sessionFactory.OpenSession()
			Dim employee = session.Get(Of Employee)(id)
			Console.WriteLine("Read Employee: " & employee.FirstName & " " & employee.LastName)
		End Using
	End Sub
	Private Shared Sub UpdateEmployee(ByVal id As Integer, ByVal newFirstName As String)
		Using session = sessionFactory.OpenSession()
		Using transaction = session.BeginTransaction()
			Dim employee = session.Get(Of Employee)(id)
			employee.FirstName = newFirstName
			session.Update(employee)
			transaction.Commit()
			Console.WriteLine("Employee updated: " & employee.FirstName)
		End Using
		End Using
	End Sub
	Private Shared Sub DeleteEmployee(ByVal id As Integer)
		Using session = sessionFactory.OpenSession()
		Using transaction = session.BeginTransaction()
			Dim employee = session.Get(Of Employee)(id)
			session.Delete(employee)
			transaction.Commit()
			Console.WriteLine("Employee deleted")
		End Using
		End Using
	End Sub
End Class

Funktionen für Datenbankportabilität und Interoperabilität

NHibernate ist auf die Portabilität von Datenbanken ausgelegt. Dank seiner Dialektkonfiguration kann NHibernate an die meisten SQL-Datenbanken mit minimalen Änderungen an der Codebasis angepasst werden. Das bedeutet, dass Sie von einem SQL-Server zu MySQL oder Oracle wechseln können, ohne Ihre Datenzugriffsschicht neu schreiben zu müssen.

Anpassung von NHibernate für verschiedene Datenbanksysteme wie SQL Server

Die XML-Konfigurationsdateien in NHibernate ermöglichen es Entwicklern, den für ihr Datenbanksystem spezifischen SQL-Dialekt anzugeben. Dies macht NHibernate zu einer flexiblen Lösung, die leicht an praktisch jede relationale Datenbank, die SQL unterstützt, angepasst werden kann, um sicherzustellen, dass Ihre Anwendung über verschiedene Datenbanksysteme hinweg portabel ist.

Verwendung von NHibernate mit IronPDF

Integration von NHibernate mitIronPDF ist eine leistungsstarke Kombination, die Ihre .NET-Anwendungen verbessern kann. Es ermöglicht Ihnen, Datenbankoperationen mit NHibernate zu verwalten und gleichzeitig IronPDF zu nutzen, umpDF-Dokumente erzeugen aus Ihren Daten. Stellen Sie sich ein Szenario vor, in dem Ihre Anwendung benutzerspezifische Dokumente bereitstellen muss, wie z. B. Mitarbeiterberichte, die im PDF-Format erstellt und heruntergeladen werden müssen. NHibernate C kann die Datenabrufe aus Ihrer Datenbank effizient verwalten, während IronPDF diese Daten in gut formatierte PDF-Dateien umwandeln kann.

IronPDF installieren

Stellen Sie zunächst sicher, dass IronPDF zu Ihrem Projekt hinzugefügt wird. Sie können es über den NuGet Package Manager einbinden, indem Sie das IronPDF-Paket installieren.

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Code-Beispiel

Lassen Sie uns genauer untersuchen, wie Sie dies in Ihrer Anwendung umsetzen können. Nach der Einrichtung von NHibernate und dem Abrufen der erforderlichen Daten aus der Datenbank, z. B. der Mitarbeiterdaten, erstellen Sie eine HTML-Vorlage, die das Aussehen des PDF-Dokuments darstellt. Diese HTML-Vorlage kann dynamisch mit Daten aus NHibernate gefüllt werden. Wenn Sie zum Beispiel einen Bericht für einen Mitarbeiter erstellen, würde die Vorlage Platzhalter für den Namen, die ID und andere relevante Details des Mitarbeiters enthalten.

Hier finden Sie ein ausführliches Codebeispiel, das den Abruf von Daten mit NHibernate und die Konvertierung in ein PDF-Dokument mit IronPDF demonstriert:

using IronPdf;
using NHibernate;
static void CreateEmployeeReport(int employeeId)
{
    // Open a session to interact with the database
    using (var session = OpenSession())
    {
        // Retrieve the employee object based on the provided ID
        var employee = session.Get<Employee>(employeeId);
        // Create an instance of the HtmlToPdf class from IronPDF
        var renderer = new ChromePdfRenderer();
        // Create the HTML content for the PDF, embedding employee data into the HTML
        var htmlTemplate = $@"
            <html>
            <head>
                <title>Employee Report</title>
            </head>
            <body>
                <h1>Employee Details</h1>
                <p>Name: {employee.FirstName} {employee.LastName}</p>
                <p>ID: {employee.ID}</p>
            </body>
            </html>";
        // Render the HTML string as a PDF document
        var pdf = renderer.RenderHtmlAsPdf(htmlTemplate);
        // Save the generated PDF to a file
        pdf.SaveAs("EmployeeReport.pdf");
    }
}

using IronPdf;
using NHibernate;
static void CreateEmployeeReport(int employeeId)
{
    // Open a session to interact with the database
    using (var session = OpenSession())
    {
        // Retrieve the employee object based on the provided ID
        var employee = session.Get<Employee>(employeeId);
        // Create an instance of the HtmlToPdf class from IronPDF
        var renderer = new ChromePdfRenderer();
        // Create the HTML content for the PDF, embedding employee data into the HTML
        var htmlTemplate = $@"
            <html>
            <head>
                <title>Employee Report</title>
            </head>
            <body>
                <h1>Employee Details</h1>
                <p>Name: {employee.FirstName} {employee.LastName}</p>
                <p>ID: {employee.ID}</p>
            </body>
            </html>";
        // Render the HTML string as a PDF document
        var pdf = renderer.RenderHtmlAsPdf(htmlTemplate);
        // Save the generated PDF to a file
        pdf.SaveAs("EmployeeReport.pdf");
    }
}

Imports IronPdf
Imports NHibernate
Shared Sub CreateEmployeeReport(ByVal employeeId As Integer)
	' Open a session to interact with the database
	Using session = OpenSession()
		' Retrieve the employee object based on the provided ID
		Dim employee = session.Get(Of Employee)(employeeId)
		' Create an instance of the HtmlToPdf class from IronPDF
		Dim renderer = New ChromePdfRenderer()
		' Create the HTML content for the PDF, embedding employee data into the HTML
		Dim htmlTemplate = $"
            <html>
            <head>
                <title>Employee Report</title>
            </head>
            <body>
                <h1>Employee Details</h1>
                <p>Name: {employee.FirstName} {employee.LastName}</p>
                <p>ID: {employee.ID}</p>
            </body>
            </html>"
		' Render the HTML string as a PDF document
		Dim pdf = renderer.RenderHtmlAsPdf(htmlTemplate)
		' Save the generated PDF to a file
		pdf.SaveAs("EmployeeReport.pdf")
	End Using
End Sub

In diesem Code wird OpenSession() ist eine Methode, die eine NHibernate-Sitzung initialisiert, die zum Abrufen der Mitarbeiterdaten verwendet wird. Die Klasse "ChromePdfRenderer" von IronPDF übernimmt dann die mit den abgerufenen Daten gefüllte HTML-Vorlage und rendert sie als PDF. Diese PDF-Datei wird lokal gespeichert, kann aber auch über eine Webschnittstelle direkt an einen Benutzer übertragen werden.

Schlussfolgerung

In diesem Tutorial haben wir untersucht, wie NHibernate die Datenbankoperationen in .NET-Anwendungen vereinfacht und wie seine Integration mit IronPDF die Funktionalität durch die Generierung dynamischer PDF-Dokumente verbessert. NHibernate bietet robuste Datenverwaltungswerkzeuge, während IronPDF eine bequeme Möglichkeit bietet, aus HTML-Vorlagen mit Daten professionelle PDF-Dateien zu erstellen.

IronPDF ist erhältlich für einenkostenloser Test, und Lizenzen beginnen bei $749, und bieten eine kostengünstige Lösung zur Integration leistungsstarker PDF-Erstellung in Ihre Anwendungen. Zusammen bieten diese Werkzeuge eine umfassende Lösung für die Verwaltung von Daten und die Erstellung von Dokumenten, die sich sowohl für Unternehmen als auch für kleinere Projekte eignet.