NHibernate C# (jak to działa dla programistów)

Rola ORM w upraszczaniu interakcji z bazami danych

Frameworki ORM, takie jak NHibernate, upraszczają interakcje z relacyjnymi bazami danych, umożliwiając programistom pracę z danymi w postaci obiektów i ich właściwości, a nie za pomocą instrukcji SQL. Ta abstrakcja pomaga programistom skupić się bardziej na logice biznesowej swoich aplikacji, a mniej na podstawowych poleceniach SQL i schemacie bazy danych. Na przykład NHibernate obsługuje całe generowanie i wykonywanie kodu SQL, umożliwiając przeprowadzanie operacji, takich jak wstawianie, usuwanie i aktualizowanie, za pomocą prostej konwersji obiektów i manipulacji obiektami.

Konfiguracja NHibernate w projekcie .NET

Aby rozpocząć pracę z NHibernate w projekcie .NET, pierwszym krokiem jest zainstalowanie pakietu NHibernate. Można to łatwo zrobić za pomocą menedżera pakietów NuGet w Visual Studio, używając następującego polecenia:

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>

Zrozumienie podstawowych komponentów NHibernate

Jednym z kluczowych komponentów NHibernate jest Session Factory, zaprojektowana z wykorzystaniem wzorca projektowego fabryki. Ten komponent tworzy obiekty Session, które zarządzają połączeniem z bazą danych i przechowują operacje transakcyjne. Utworzenie fabryki sesji jest kosztowne, więc zazwyczaj wykonuje się to tylko raz w całym cyklu życia aplikacji, co czyni ją kluczowym elementem optymalizacji wydajności.

Mapowanie encji do tabel bazy danych za pomocą NHibernate

Mapowanie encji w NHibernate odbywa się za pomocą plików mapujących, zazwyczaj napisanych w formacie XML. Pliki te, często nazwane na cześć klasy encji (np. Employee.hbm.xml), definiują sposób, w jaki właściwości encji są mapowane na kolumny tabeli bazy danych. Typowy plik mapowania zawiera nazwę klasy, nazwę tabeli oraz szczegóły dotyczące każdej właściwości, w tym klucz główny, nazwę kolumny i typ danych.

Wykonywanie poleceń SQL i transakcji w NHibernate

NHibernate upraszcza operacje CRUD (tworzenie, odczyt, aktualizacja, usuwanie) poprzez abstrakcję podstawowych poleceń SQL. Programiści mogą wykonywać te operacje bez pisania jawnego kodu SQL, korzystając zamiast tego z metod udostępnianych przez interfejs ISession. Na przykład, aby dodać nowy obiekt do bazy danych, wystarczy utworzyć nową instancję obiektu, ustawić jego właściwości i użyć metody Save klasy ISession.

Pełny przykład kodu

Ten przykład obejmuje konfigurację plików konfiguracyjnych i mapujących NHibernate oraz pokazuje, jak wykonywać operacje tworzenia, odczytu, aktualizacji i usuwania przy użyciu NHibernate.

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

Funkcje przenośności i interoperacyjności baz danych

NHibernate został zaprojektowany z myślą o przenośności baz danych. Dzięki konfiguracji dialektu NHibernate może dostosować się do większości baz danych SQL przy minimalnych zmianach w kodzie źródłowym. Oznacza to, że można przejść z serwera SQL na MySQL lub Oracle bez konieczności przepisywania warstwy dostępu do danych.

Korzystanie z NHibernate z IronPDF

Integracja NHibernate z IronPDF to potężne połączenie, które może wzbogacić Twoje aplikacje .NET. Pozwala to zarządzać operacjami bazodanowymi za pomocą NHibernate, jednocześnie wykorzystując IronPDF do generowania dokumentów PDF na podstawie danych. Rozważmy scenariusz, w którym aplikacja musi udostępniać dokumenty specyficzne dla użytkownika, takie jak raporty pracowników, które należy wygenerować i pobrać w formacie PDF. NHibernate może efektywnie zarządzać procesami pobierania danych z bazy danych, a IronPDF może konwertować te dane na dobrze sformatowane pliki PDF.

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

Wnioski

W tym samouczku omówiliśmy, w jaki sposób NHibernate upraszcza operacje na bazach danych w aplikacjach .NET oraz jak jego integracja z IronPDF zwiększa funkcjonalność, umożliwiając generowanie dynamicznych dokumentów PDF. NHibernate zapewnia solidne narzędzia do zarządzania danymi, a IronPDF oferuje wygodny sposób tworzenia profesjonalnych plików PDF na podstawie szablonów HTML wypełnionych danymi.

IronPDF jest dostępny w ramach bezpłatnej wersji próbnej, a ceny licencji zaczynają się od opłacalnego rozwiązania umożliwiającego integrację zaawansowanego generowania plików PDF z aplikacjami użytkownika. W połączeniu narzędzia te oferują kompleksowe rozwiązanie do zarządzania danymi i tworzenia dokumentów, idealne zarówno dla projektów na skalę Enterprise, jak i tych o mniejszym zasięgu.