NHibernate em C# (Como funciona para desenvolvedores)

O papel do ORM na simplificação das interações com o banco de dados

Frameworks ORM como o NHibernate simplificam as interações com bancos de dados relacionais, permitindo que os desenvolvedores trabalhem com dados em termos de objetos e suas propriedades, em vez de instruções SQL. Essa abstração ajuda os desenvolvedores a se concentrarem mais na lógica de negócios de seus aplicativos e menos nos comandos SQL subjacentes e no esquema do banco de dados. Por exemplo, o NHibernate lida com toda a geração e execução de SQL, permitindo que operações como inserções, exclusões e atualizações sejam realizadas com simples conversão e manipulação de objetos.

Configurando o NHibernate em um projeto .NET

Para começar a usar o NHibernate em seu projeto .NET , o primeiro passo é instalar o pacote NHibernate. Isso pode ser feito facilmente através do Gerenciador de Pacotes NuGet do Visual Studio, usando o seguinte comando:

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>

Entendendo os Componentes Principais do NHibernate

Um dos componentes principais do NHibernate é a Session Factory, que foi projetada utilizando o padrão de projeto Factory. Este componente cria objetos de sessão que gerenciam a conexão com o banco de dados e armazenam as operações transacionais. A criação da Session Factory é dispendiosa, por isso geralmente é feita apenas uma vez durante o ciclo de vida da aplicação, tornando-a um elemento crucial para a otimização do desempenho.

Mapeamento de entidades para tabelas de banco de dados com NHibernate

O mapeamento de entidades no NHibernate é realizado por meio de arquivos de mapeamento, geralmente escritos em XML. Esses arquivos, geralmente nomeados de acordo com a classe da entidade (por exemplo, Employee.hbm.xml ), definem como as propriedades de uma entidade são mapeadas para as colunas de uma tabela do banco de dados. Um arquivo de mapeamento típico inclui o nome da classe, o nome da tabela e detalhes sobre cada propriedade, incluindo a chave primária, o nome da coluna e o tipo de dados.

Executando comandos SQL e transações no NHibernate

O NHibernate simplifica as operações CRUD (Criar, Ler, Atualizar, Excluir) ao abstrair os comandos SQL subjacentes. Os desenvolvedores podem realizar essas operações sem escrever código SQL explícito, usando, em vez disso, os métodos fornecidos pela interface ISession. Por exemplo, para adicionar uma nova entidade ao banco de dados, você simplesmente cria uma nova instância do objeto, define suas propriedades e usa o método Save do ISession.

Exemplo de código completo

Este exemplo inclui a configuração dos arquivos de configuração e mapeamento do NHibernate e demonstra como realizar operações de criação, leitura, atualização e exclusão usando o 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

Recursos de Portabilidade e Interoperabilidade de Banco de Dados

O NHibernate foi projetado com a portabilidade de banco de dados já garantida. Graças à sua configuração de dialetos, o NHibernate pode se adaptar à maioria dos bancos de dados SQL com alterações mínimas no código-fonte. Isso significa que você pode migrar de um servidor SQL para MySQL ou Oracle sem precisar reescrever sua camada de acesso a dados.

Utilizando NHibernate com IronPDF

A integração do NHibernate com o IronPDF é uma combinação poderosa que pode aprimorar seus aplicativos .NET . Ele permite gerenciar operações de banco de dados com o NHibernate, enquanto utiliza o IronPDF para gerar documentos PDF a partir dos seus dados. Considere um cenário em que seu aplicativo precisa fornecer documentos específicos do usuário, como relatórios de funcionários, que precisam ser gerados e baixados em formato PDF. O NHibernate pode gerenciar com eficiência os processos de recuperação de dados do seu banco de dados, enquanto o IronPDF pode converter esses dados em arquivos PDF bem formatados.

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

Conclusão

Neste tutorial, exploramos como o NHibernate simplifica as operações de banco de dados em aplicações .NET e como sua integração com o IronPDF aprimora a funcionalidade, permitindo a geração de documentos PDF dinâmicos. O NHibernate oferece ferramentas robustas de gerenciamento de dados, enquanto o IronPDF proporciona uma maneira prática de criar PDFs com qualidade profissional a partir de modelos HTML preenchidos com dados.

O IronPDF está disponível para teste gratuito , e as licenças começam em um valor acessível, sendo uma solução ideal para integrar a geração de PDFs de alta qualidade em seus aplicativos. Em conjunto, essas ferramentas oferecem uma solução abrangente para gerenciar dados e produzir documentos, ideal tanto para projetos de grande porte quanto para projetos de menor escala.