AYUDA .NET

NHibernate C# (Cómo funciona para desarrolladores)

Actualizado 6 de junio, 2024
Compartir:

NHibernate C# (Cómo funciona para desarrolladores): Figura 1 - Página de inicio de NHibernate C#

NHibernate es una potente herramienta de mapeo relacional de objetos (ORM) diseñado para su uso con el marco .NET. Proporciona a los desarrolladores una forma eficaz de tender puentes entre el mundo orientado a objetos de las aplicaciones .NET y el mundo relacional de las bases de datos. Al utilizar NHibernate, puede reducir significativamente la cantidad de código repetitivo necesario para implementar capas de acceso a datos, lo que hace que sus aplicaciones .NET sean más limpias y fáciles de mantener.

El papel de ORM en la simplificación de las interacciones con las bases de datos

Los marcos ORM como NHibernate simplifican las interacciones con las bases de datos relacionales al permitir a los desarrolladores trabajar con datos en términos de objetos y sus propiedades en lugar de sentencias SQL. Esta abstracción ayuda a los desarrolladores a centrarse más en la lógica empresarial de sus aplicaciones y menos en los comandos SQL subyacentes y el esquema de la base de datos. Por ejemplo, NHibernate se encarga de toda la generación y ejecución de SQL, lo que permite realizar operaciones como inserciones, eliminaciones y actualizaciones con una simple conversión y manipulación de objetos.

Configuración de NHibernate en un proyecto .NET

Para empezar a utilizar NHibernate en su proyecto .NET, el primer paso es instalar el paquete NHibernate. Esto se puede hacer fácilmente a través de NuGet Package Manager de Visual Studio mediante el siguiente comando:

Install-Package IronPdf

NHibernate C# (Cómo funciona para desarrolladores): Figura 2 - Abra una consola de línea de comandos e introduzca el comando anterior para instalar NHibernate

Configuración de NHibernate con el archivo de configuración XML

Una vez instalado NHibernate, el siguiente paso es configurarlo. Esto implica crear un archivo de asignación de Hibernate que detalle la configuración del servidor de base de datos y los detalles de asignación de los objetos a las tablas de la base de datos. El archivo XML principal, normalmente llamado hibernate.cfg.xml, incluye ajustes como la cadena de conexión a la base de datos, el dialecto y otros ajustes específicos de la base de datos.

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

Comprender los componentes básicos de NHibernate

Uno de los componentes clave de NHibernate es la fábrica de sesiones, que está diseñada utilizando el patrón de diseño de fábrica. Este componente crea objetos Session que gestionan la conexión a la base de datos y mantienen las operaciones transaccionales. La creación de la Fábrica de Sesiones es costosa, por lo que suele hacerse una vez por vida de la aplicación, lo que la convierte en un elemento crucial para la optimización del rendimiento.

Clases y métodos clave en NHibernate

NHibernate gira en torno a varias clases y métodos esenciales. Por ejemplo, la interfaz ISession desempeña un papel fundamental en NHibernate, ya que facilita la creación de sesiones de consulta y manipulación de datos. Métodos como OpenSession ayudan a los desarrolladores a iniciar transacciones, ejecutar comandos SQL y consultar la base de datos utilizando sentencias SQL o el propio HQL de NHibernate. (Lenguaje de consulta de Hibernate).

Asignación de entidades a tablas de base de datos con NHibernate

La asignación de entidades en NHibernate se realiza mediante archivos de asignación, normalmente escritos en XML. Estos archivos, que a menudo reciben el nombre de la clase de entidad (por ejemplo, Empleado.hbm.xml)definen la correspondencia entre las propiedades de una entidad y las columnas de una tabla de base de datos. Un archivo de asignación típico incluye el nombre de la clase, el nombre de la tabla y detalles sobre cada propiedad, incluida la clave principal, el nombre de la columna y el tipo de datos.

Propiedades y atributos de los ficheros de asignación

En estos archivos de asignación, puede especificar varios atributos para cada propiedad, como restricciones no nulas o restricciones únicas. NHibernate también permite asignaciones complejas como las relaciones uno a muchos y muchos a uno, lo que proporciona un potente conjunto de herramientas para representar estructuras de datos relacionales dentro de un marco orientado a objetos.

Ejecución de comandos SQL y transacciones en NHibernate

NHibernate simplifica el CRUD (Crear, Leer, Actualizar, Suprimir) abstrayendo los comandos SQL subyacentes. Los desarrolladores pueden realizar estas operaciones sin escribir código SQL explícito, utilizando en su lugar los métodos proporcionados por la interfaz ISession. Por ejemplo, para añadir una nueva entidad a la base de datos, basta con crear una nueva instancia del objeto, establecer sus propiedades y utilizar el método Save de la ISession.

Gestión de transacciones con ITransaction.

Las transacciones en NHibernate se gestionan a través de la interfaz ITransaction, que garantiza la integridad y coherencia de los datos. Utilizando el método BeginTransaction de ISession, los desarrolladores pueden asegurarse de que todas las operaciones se completan con éxito antes de enviar los datos a la base de datos, o volver atrás si algo va mal, manteniendo así la estabilidad de sus datos.

Ejemplo de código completo

Este ejemplo incluye la configuración de los archivos de configuración y asignación de NHibernate y muestra cómo realizar operaciones de creación, lectura, actualización y eliminación utilizando NHibernate.

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
VB   C#

Portabilidad de bases de datos e interoperabilidad

NHibernate está diseñado con portabilidad de base de datos entregada. Gracias a su configuración de dialectos, NHibernate puede adaptarse a la mayoría de las bases de datos SQL con cambios mínimos en el código base. Esto significa que puede cambiar de un servidor SQL a MySQL u Oracle sin tener que reescribir su capa de acceso a datos.

Adaptación de NHibernate a varios sistemas de bases de datos como SQL Server

Los archivos de configuración XML de NHibernate permiten a los desarrolladores especificar el dialecto SQL específico de su sistema de base de datos. Esto convierte a NHibernate en una solución flexible que puede adaptarse fácilmente para trabajar con prácticamente cualquier base de datos relacional que admita SQL, lo que garantiza la portabilidad de su aplicación a través de diferentes sistemas de bases de datos.

Uso de NHibernate con IronPDF

NHibernate C# (Cómo funciona para desarrolladores): Figura 3 - Página de inicio de IronPDF

Integración de NHibernate con IronPDF es una potente combinación que puede mejorar sus aplicaciones .NET. Le permite gestionar operaciones de base de datos con NHibernate al tiempo que aprovecha IronPDF para generar documentos PDF de sus datos. Piense en una situación en la que su aplicación necesita proporcionar documentos específicos de usuario, como informes de empleados, que deben generarse y descargarse en formato PDF. NHibernate C puede gestionar eficazmente los procesos de recuperación de datos de su base de datos, mientras que IronPDF puede convertir estos datos en archivos PDF bien formateados.

Instalar IronPDF

En primer lugar, asegúrese de que IronPDF está añadido a su proyecto. Puede incluirlo a través del gestor de paquetes NuGet instalando el paquete IronPDF.

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

NHibernate C# (Cómo funciona para desarrolladores): Figura 4 - Instalación de IronPDF a través del gestor de paquetes NuGet

Ejemplo de código

Profundicemos en cómo implementar esto en tu aplicación. Después de configurar NHibernate y recuperar los datos necesarios de la base de datos, como los detalles de los empleados, preparará una plantilla HTML que represente cómo debe aparecer el documento PDF. Esta plantilla HTML puede rellenarse dinámicamente con datos obtenidos de NHibernate. Por ejemplo, si está generando un informe para un empleado, la plantilla incluiría marcadores de posición para el nombre del empleado, su ID y otros detalles relevantes.

A continuación se muestra un ejemplo de código detallado que demuestra la obtención de datos mediante NHibernate y su conversión a PDF mediante IronPDF:

using IronPdf;
using NHibernate;
static void CreateEmployeeReport(int employeeId)
{
    //  Abrir una sesión para interactuar con la base de datos
    using (var session = OpenSession())
    {
        //  Recuperar el objeto empleado basado en el ID proporcionado
        var employee = session.Get<Employee>(employeeId);
        //  Crear una instancia de la clase HtmlToPdf de IronPDF
        var renderer = new ChromePdfRenderer();
        //  Crear el contenido HTML para el PDF, incrustando los datos de los empleados en el 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>";
        //  Convertir la cadena HTML en un documento PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlTemplate);
        //  Guardar el PDF generado en un archivo
        pdf.SaveAs("EmployeeReport.pdf");
    }
}
using IronPdf;
using NHibernate;
static void CreateEmployeeReport(int employeeId)
{
    //  Abrir una sesión para interactuar con la base de datos
    using (var session = OpenSession())
    {
        //  Recuperar el objeto empleado basado en el ID proporcionado
        var employee = session.Get<Employee>(employeeId);
        //  Crear una instancia de la clase HtmlToPdf de IronPDF
        var renderer = new ChromePdfRenderer();
        //  Crear el contenido HTML para el PDF, incrustando los datos de los empleados en el 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>";
        //  Convertir la cadena HTML en un documento PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlTemplate);
        //  Guardar el PDF generado en un archivo
        pdf.SaveAs("EmployeeReport.pdf");
    }
}
Imports IronPdf
Imports NHibernate
Shared Sub CreateEmployeeReport(ByVal employeeId As Integer)
	'  Abrir una sesión para interactuar con la base de datos
	Using session = OpenSession()
		'  Recuperar el objeto empleado basado en el ID proporcionado
		Dim employee = session.Get(Of Employee)(employeeId)
		'  Crear una instancia de la clase HtmlToPdf de IronPDF
		Dim renderer = New ChromePdfRenderer()
		'  Crear el contenido HTML para el PDF, incrustando los datos de los empleados en el 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>"
		'  Convertir la cadena HTML en un documento PDF
		Dim pdf = renderer.RenderHtmlAsPdf(htmlTemplate)
		'  Guardar el PDF generado en un archivo
		pdf.SaveAs("EmployeeReport.pdf")
	End Using
End Sub
VB   C#

NHibernate C# (Cómo funciona para desarrolladores): Figura 5 - Ejemplo de salida del código anterior

En este código, OpenSession() es un método que inicializa una sesión de NHibernate, que se utiliza para obtener los datos de los empleados. La clase ChromePdfRenderer de IronPDF toma la plantilla HTML rellenada con los datos obtenidos y la renderiza como PDF. Este PDF se guarda localmente, pero también podría transmitirse directamente a un usuario a través de una interfaz web.

Conclusión

NHibernate C# (Cómo funciona para desarrolladores): Figura 6 - Página de licencias de IronPDF

En este tutorial, hemos explorado cómo NHibernate simplifica las operaciones de base de datos en aplicaciones .NET y cómo su integración con IronPDF mejora la funcionalidad al permitir la generación de documentos PDF dinámicos. NHibernate proporciona sólidas herramientas de gestión de datos, mientras que IronPDF ofrece una forma cómoda de crear PDF de calidad profesional a partir de plantillas HTML llenas de datos.

IronPDF está disponible por un prueba gratuita y las licencias comienzan en 749 dólares, ofreciendo una solución rentable para integrar una potente generación de PDF en sus aplicaciones. Juntas, estas herramientas ofrecen una solución completa para la gestión de datos y la producción de documentos, ideal tanto para proyectos empresariales como de menor envergadura.

< ANTERIOR
Ocelot .NET (Cómo funciona para desarrolladores)
SIGUIENTE >
Ejemplo de Rebus .NET Core (Cómo funciona para los desarrolladores)

¿Listo para empezar? Versión: 2024.7 recién publicada

Descarga gratuita de NuGet Descargas totales: 9,848,088 Ver licencias >
123