NHibernate C# (Funktionsweise für Entwickler)

Die Rolle von ORM bei der Vereinfachung von Datenbankinteraktionen

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

Einrichten von NHibernate in einem .NET-Projekt

Um mit NHibernate in Ihrem .NET-Projekt zu beginnen, ist der erste Schritt die Installation des NHibernate-Pakets. Dies kann leicht über den NuGet-Paketmanager von Visual Studio mit dem folgenden Befehl erledigt werden:

Install-Package NHibernate

<?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>

Verstehen der Kernkomponenten von NHibernate

Eine der Schlüsselkomponenten in NHibernate ist die Session Factory, die nach dem Factory-Designmuster entworfen wurde. Diese Komponente erstellt Sitzungsobjekte, die die Verbindung zur Datenbank verwalten und die Transaktionsoperationen halten. Die Session Factory ist kostspielig zu erstellen, daher wird sie in der Regel nur einmal pro Anwendungslebensdauer erstellt, was sie zu einem entscheidenden Element für Leistungsoptimierung macht.

Mapping von Entitäten auf Datenbanktabellen mit NHibernate

In NHibernate erfolgt die Entity-Zuordnung durch Mapping-Dateien, die normalerweise in XML geschrieben werden. Diese Dateien, oft nach der Entity-Klasse benannt (z.B. Employee.hbm.xml), definieren, wie die Eigenschaften einer Entity zu den Spalten einer Datenbanktabelle zugeordnet werden. Eine typische Mapping-Datei enthält den Klassennamen, den Tabellennamen und Details zu jeder Eigenschaft, einschließlich des Primärschlüssels, des Spaltennamens und des Datentyps.

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

NHibernate vereinfacht CRUD-Operationen (Create, Read, Update, Delete), indem es die zugrunde liegenden SQL-Befehle abstrahiert. Entwickler können diese Operationen durchführen, ohne expliziten SQL-Code zu schreiben, indem sie stattdessen Methoden verwenden, die von der ISession Schnittstelle bereitgestellt werden. Um beispielsweise eine neue Entität zur Datenbank hinzuzufügen, erstellen Sie einfach eine neue Instanz des Objekts, legen dessen Eigenschaften fest und verwenden die Methode Save der Klasse ISession.

Komplettes Code-Beispiel

Dieses Beispiel umfasst die Konfiguration der NHibernate-Konfiguration und der Mapping-Dateien und zeigt, wie man Create-, Read-, Update- und Delete-Operationen mit NHibernate durchführt.

using NHibernate;
using NHibernate.Cfg;
using System;

// Define the Employee class with virtual properties
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()
    {
        // Initialize the SessionFactory using NHibernate configuration
        sessionFactory = new Configuration().Configure().BuildSessionFactory();

        // Perform database operations
        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); // Save the new Employee object to the database
            transaction.Commit(); // Commit the transaction to finalize the insertion
            Console.WriteLine("Employee created: " + newEmployee.Id);
        }
    }

    static void ReadEmployee(int id)
    {
        using (var session = sessionFactory.OpenSession())
        {
            // Retrieve the Employee object by its Id
            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())
        {
            // Get the Employee object by its Id
            var employee = session.Get<Employee>(id);
            employee.FirstName = newFirstName; // Update the employee's first name
            session.Update(employee); // Update the Employee object in the database
            transaction.Commit(); // Commit the transaction to save changes
            Console.WriteLine("Employee updated: " + employee.FirstName);
        }
    }

    static void DeleteEmployee(int id)
    {
        using (var session = sessionFactory.OpenSession())
        using (var transaction = session.BeginTransaction())
        {
            // Retrieve the Employee object to be deleted
            var employee = session.Get<Employee>(id);
            session.Delete(employee); // Delete the Employee from the database
            transaction.Commit(); // Commit the transaction to finalize the deletion
            Console.WriteLine("Employee deleted");
        }
    }
}

using NHibernate;
using NHibernate.Cfg;
using System;

// Define the Employee class with virtual properties
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()
    {
        // Initialize the SessionFactory using NHibernate configuration
        sessionFactory = new Configuration().Configure().BuildSessionFactory();

        // Perform database operations
        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); // Save the new Employee object to the database
            transaction.Commit(); // Commit the transaction to finalize the insertion
            Console.WriteLine("Employee created: " + newEmployee.Id);
        }
    }

    static void ReadEmployee(int id)
    {
        using (var session = sessionFactory.OpenSession())
        {
            // Retrieve the Employee object by its Id
            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())
        {
            // Get the Employee object by its Id
            var employee = session.Get<Employee>(id);
            employee.FirstName = newFirstName; // Update the employee's first name
            session.Update(employee); // Update the Employee object in the database
            transaction.Commit(); // Commit the transaction to save changes
            Console.WriteLine("Employee updated: " + employee.FirstName);
        }
    }

    static void DeleteEmployee(int id)
    {
        using (var session = sessionFactory.OpenSession())
        using (var transaction = session.BeginTransaction())
        {
            // Retrieve the Employee object to be deleted
            var employee = session.Get<Employee>(id);
            session.Delete(employee); // Delete the Employee from the database
            transaction.Commit(); // Commit the transaction to finalize the deletion
            Console.WriteLine("Employee deleted");
        }
    }
}

Imports NHibernate
Imports NHibernate.Cfg
Imports System

' Define the Employee class with virtual properties
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()
		' Initialize the SessionFactory using NHibernate configuration
		sessionFactory = (New Configuration()).Configure().BuildSessionFactory()

		' Perform database operations
		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) ' Save the new Employee object to the database
			transaction.Commit() ' Commit the transaction to finalize the insertion
			Console.WriteLine("Employee created: " & newEmployee.Id)
		End Using
		End Using
	End Sub

	Private Shared Sub ReadEmployee(ByVal id As Integer)
		Using session = sessionFactory.OpenSession()
			' Retrieve the Employee object by its Id
			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()
			' Get the Employee object by its Id
			Dim employee = session.Get(Of Employee)(id)
			employee.FirstName = newFirstName ' Update the employee's first name
			session.Update(employee) ' Update the Employee object in the database
			transaction.Commit() ' Commit the transaction to save changes
			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()
			' Retrieve the Employee object to be deleted
			Dim employee = session.Get(Of Employee)(id)
			session.Delete(employee) ' Delete the Employee from the database
			transaction.Commit() ' Commit the transaction to finalize the deletion
			Console.WriteLine("Employee deleted")
		End Using
		End Using
	End Sub
End Class

Merkmale der Datenbank-Portabilität und Interoperabilität

NHibernate ist mit Datenbankportabilität konzipiert. Dank seiner Dialektkonfiguration kann NHibernate sich mit minimalen Änderungen des Code-Designs an die meisten SQL-Datenbanken anpassen. Das bedeutet, dass Sie von einem SQL-Server zu MySQL oder Oracle wechseln können, ohne Ihre Datenzugriffsschicht neu schreiben zu müssen.

NHibernate mit IronPDF verwenden

Die Integration von NHibernate mit IronPDF ist eine leistungsstarke Kombination, die Ihre .NET-Anwendungen verbessern kann. Es ermöglicht Ihnen, Datenbankoperationen mit NHibernate zu verwalten, während Sie IronPDF verwenden, um PDF-Dokumente zu generieren aus Ihren Daten. Betrachten Sie ein Szenario, in dem Ihre Anwendung benutzerspezifische Dokumente bereitstellen muss, wie z.B. Mitarbeiterberichte, die im PDF-Format generiert und heruntergeladen werden müssen. NHibernate kann effizient die Datenabrufprozesse aus Ihrer Datenbank verwalten, während IronPDF in der Lage ist, diese Daten in gut formatierte PDF-Dateien umzuwandeln.

Install-Package IronPdf

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 ChromePdfRenderer 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 ChromePdfRenderer 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 ChromePdfRenderer 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

Abschluss

In diesem Tutorial haben wir untersucht, wie NHibernate Datenbankoperationen in .NET-Anwendungen vereinfacht und wie seine Integration mit IronPDF die Funktionalität verbessert, indem sie die Erstellung dynamischer PDF-Dokumente ermöglicht. NHibernate bietet robuste Datenmanagement-Tools, während IronPDF eine bequeme Möglichkeit bietet, professionelle PDFs aus mit Daten gefüllten HTML-Vorlagen zu erstellen.

IronPDF ist für eine kostenlose Testversion verfügbar, und Lizenzen beginnen bei einer kostengünstigen Lösung für die Integration leistungsstarker PDF-Generierung in Ihre Anwendungen. Zusammen bieten diese Tools eine umfassende Lösung für Datenmanagement und Dokumenterstellung, ideal für sowohl unternehmensweite als auch kleinere Projekte.