NHibernate est un puissant framework de mapping objet-relationnel (ORM) conçu pour être utilisé avec le framework .NET. Il offre aux développeurs un moyen efficace de combler le fossé entre le monde orienté objet des applications .NET et le monde relationnel des bases de données. En utilisant NHibernate, vous pouvez réduire considérablement la quantité de code standard requise pour implémenter des couches d'accès aux données, rendant vos applications .NET plus propres et plus faciles à maintenir.
Les frameworks ORM comme NHibernate simplifient les interactions avec les bases de données relationnelles en permettant aux développeurs de travailler avec des données en termes d'objets et de leurs propriétés plutôt qu'en utilisant des instructions SQL. Cette abstraction aide les développeurs à se concentrer davantage sur la logique métier de leurs applications et moins sur les commandes SQL sous-jacentes et le schéma de la base de données. Par exemple, NHibernate gère toute la génération et l'exécution des SQL, permettant des opérations telles que les insertions, les suppressions et les mises à jour à effectuer par une simple conversion d'objets et manipulation d'objets.
Pour commencer avec NHibernate dans votre projet .NET, la première étape est d'installer le package NHibernate. Cela peut être fait facilement via le gestionnaire de packages NuGet de Visual Studio en utilisant la commande suivante :
Une fois NHibernate installé, l'étape suivante consiste à le configurer. Cela implique de créer un fichier de mappage Hibernate qui détaille vos paramètres de serveur de base de données et les détails de mappage de vos objets vers les tables de la base de données. Le fichier XML principal, généralement nommé hibernate.cfg.xml, inclut des paramètres tels que la chaîne de connexion de la base de données, le dialecte et d'autres paramètres spécifiques à la base de données.
<?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>L'un des composants clés de NHibernate est la Session Factory, qui est conçue en utilisant le patron de conception de fabrique. Ce composant crée des objets Session qui gèrent la connexion à la base de données et contiennent les opérations transactionnelles. La création de la Session Factory est coûteuse, elle est donc généralement faite une fois par durée de vie de l'application, en faisant un élément crucial pour l'optimisation des performances.
NHibernate tourne autour de plusieurs classes et méthodes essentielles. Par exemple, l'interface ISession joue un rôle fondamental dans NHibernate, facilitant la création de sessions de requête et de manipulation de données. Les méthodes comme OpenSession aident les développeurs à démarrer des transactions, exécuter des commandes SQL et interroger la base de données en utilisant soit des instructions SQL soit le propre HQL de NHibernate (Hibernate Query Language).
Le mappage d'entité dans NHibernate est accompli grâce à des fichiers de mappage, généralement écrits en XML. Ces fichiers, souvent nommés d'après la classe d'entité (par exemple, Employee.hbm.xml), définissent comment les propriétés d'une entité se mappent aux colonnes d'une table de base de données. Un fichier de mappage typique inclut le nom de la classe, le nom de la table, et les détails sur chaque propriété, y compris la clé primaire, le nom de la colonne, et le type de données.
Dans ces fichiers de mappage, vous pouvez spécifier divers attributs pour chaque propriété, tels que des contraintes de non-nullité ou des contraintes uniques. NHibernate permet aussi des mappages complexes comme les relations un-à-plusieurs et plusieurs-à-un, offrant un ensemble d'outils puissants pour représenter les structures de données relationnelles dans un cadre orienté objet.
NHibernate simplifie les opérations CRUD (Créer, Lire, Mettre à jour, Supprimer) en abstraisant les commandes SQL sous-jacentes. Les développeurs peuvent effectuer ces opérations sans écrire de code SQL explicite, en utilisant plutôt les méthodes fournies par l'interface ISession. Par exemple, pour ajouter une nouvelle entité à la base de données, vous créez simplement une nouvelle instance de l'objet, définissez ses propriétés et utilisez la méthode Save de ISession.
ITransactionLes transactions dans NHibernate sont gérées via l'interface ITransaction, qui assure l'intégrité et la cohérence des données. En utilisant la méthode BeginTransaction de ISession, les développeurs peuvent s'assurer que toutes les opérations sont complétées avec succès avant de valider les données dans la base de données, ou revenir en arrière si quelque chose ne va pas, maintenant ainsi la stabilité de vos données.
cet exemple comprend la configuration de la configuration NHibernate et des fichiers de mappage et démontre comment effectuer des opérations de création, de lecture, de mise à jour et de suppression en utilisant 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");
}
}
}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 ClassNHibernate est conçu avec la portabilité de la base de données en tête. Grâce à sa configuration dialecte, NHibernate peut s'adapter à la plupart des bases de données SQL avec des changements minimes dans la base de code. Cela signifie que vous pouvez passer d'un serveur SQL à MySQL ou Oracle sans avoir à réécrire votre couche d'accès aux données.
Les fichiers de configuration XML dans NHibernate permettent aux développeurs de spécifier le dialecte SQL spécifique à leur système de base de données. Cela fait de NHibernate une solution flexible qui peut être facilement adaptée pour fonctionner avec pratiquement toute base de données relationnelle qui supporte SQL, garantissant que votre application soit portable à travers différents systèmes de bases de données.
Intégrer NHibernate avec IronPDF est une combinaison puissante qui peut améliorer vos applications .NET. Cela vous permet de gérer les opérations de base de données avec NHibernate tout avec IronPDF pour générer des documents PDF à partir de vos données. Considérez un scénario où votre application doit fournir des documents spécifiques à un utilisateur, tels que des rapports d'employés, qui doivent être générés et téléchargés au format PDF. NHibernate peut gérer efficacement les processus de récupération des données de votre base de données, tandis qu'IronPDF peut convertir ces données en fichiers PDF bien formatés.
Tout d'abord, assurez-vous que IronPDF est ajouté à votre projet. Vous pouvez l'inclure via le gestionnaire de packages NuGet en installant le package IronPDF.
Approfondissons la mise en œuvre de cela dans votre application. Après avoir configuré NHibernate et récupéré les données nécessaires à partir de la base de données, telles que les détails des employés, vous préparerez un modèle HTML représentant l'apparence que devrait avoir le document PDF. Ce modèle HTML peut être rempli dynamiquement avec les données obtenues de NHibernate. Par exemple, si vous générez un rapport pour un employé, le modèle inclurait des espaces réservés pour le nom de l'employé, son ID, et d'autres détails pertinents.
Voici un exemple de code détaillé qui démontre comment extraire des données en utilisant NHibernate et les convertir en PDF à l'aide d'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");
}
}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
Dans ce code, OpenSession() est une méthode qui initialise une session NHibernate, utilisée pour récupérer les données des employés. La classe ChromePdfRenderer d'IronPDF prend alors le modèle HTML rempli avec les données récupérées et le rend en PDF. Ce PDF est enregistré localement, mais pourrait également être diffusé directement à un utilisateur via une interface Web.
Dans ce tutoriel, nous avons exploré comment NHibernate simplifie les opérations de base de données dans les applications .NET et comment son intégration avec IronPDF améliore la fonctionnalité en permettant la génération de documents PDF dynamiques. NHibernate offre des outils de gestion des données robustes, tandis qu'IronPDF offre un moyen pratique de créer des PDF de qualité professionnelle à partir de modèles HTML remplis avec des données.
IronPDF est disponible pour un essai gratuit, et les licences commencent à une solution économique pour intégrer une puissante génération de PDF dans vos applications. Ensemble, ces outils offrent une solution complète pour gérer les données et produire des documents, idéale tant pour les projets de niveau entreprise que pour ceux de plus petite envergure.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
