Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. NHibernate C#
.NET AIDE

NHibernate C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

NHibernate C# (Comment ça fonctionne pour les développeurs) : Figure 1 - Page d'accueil de NHibernate C#

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.

Le rôle de l'ORM dans la simplification des interactions avec les bases de données

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.

Configuration de NHibernate dans un projet .NET

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 :

Install-Package NHibernate

NHibernate C# (Comment ça fonctionne pour les développeurs): Figure 2 - Ouvrez une console de ligne de commande et entrez la commande ci-dessus pour installer NHibernate

Configurer NHibernate avec un fichier de configuration XML

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, comprend des paramètres tels que la chaîne de connexion à 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>
<?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

Comprendre les composants principaux de NHibernate

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.

Classes et méthodes clés dans NHibernate

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 (Hibernate Query Language) de NHibernate.

Mapper les entités aux tables de base de données avec NHibernate

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.

Examen détaillé des propriétés et attributs utilisés dans les fichiers de mappage

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.

Exécuter des commandes SQL et des transactions dans NHibernate

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, 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 l'ISession.

Gérer les transactions avec ITransaction

Les 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 effectuer un retour arrière si quelque chose tourne mal, garantissant ainsi la stabilité de vos données.

Exemple complet de code

Cet exemple inclut la configuration de NHibernate et des fichiers de mappage et montre comment effectuer des opérations Créer, Lire, Mettre à jour, et Supprimer 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");
        }
    }
}
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
$vbLabelText   $csharpLabel

Portabilité et fonctionnalités d'interopérabilité des bases de données

NHibernate 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.

Adapter NHibernate pour différents systèmes de bases de données comme SQL Server

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.

Utiliser NHibernate avec IronPDF

NHibernate C# (Comment ça fonctionne pour les développeurs) : Figure 3 - Page d'accueil d'IronPDF

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 en utilisant 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.

Installer IronPDF

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.

Install-Package IronPdf

NHibernate C# (Comment ça fonctionne pour les développeurs) : Figure 4 - Installer IronPDF via le gestionnaire de packages NuGet

Exemple de code

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");
    }
}
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
$vbLabelText   $csharpLabel

NHibernate C# (Comment ça fonctionne pour les développeurs) : Figure 5 - Exemple de sortie du code ci-dessus

Dans ce code, OpenSession() est une méthode qui initialise une session NHibernate, utilisée pour extraire les données de l'employé. La classe ChromePdfRenderer d'IronPDF prend ensuite le modèle HTML rempli avec les données extraites et le rend comme un PDF. Ce PDF est enregistré localement, mais pourrait également être diffusé directement à un utilisateur via une interface Web.

Conclusion

NHibernate C# (Comment ça fonctionne pour les développeurs) : Figure 6 - Page de licence IronPDF

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 is available for a free trial, and licenses begin at a cost-effective solution for integrating powerful PDF generation into your 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.

Questions Fréquemment Posées

Comment puis-je intégrer NHibernate avec une bibliothèque de génération de PDF en C#?

NHibernate peut être intégré à IronPDF en utilisant NHibernate pour gérer les opérations de base de données et récupérer des données, qu'IronPDF peut ensuite convertir en documents PDF. Cela permet de générer des PDF dynamiques basés sur des données spécifiques à l'utilisateur.

Quel est le but de la Session Factory dans NHibernate?

Dans NHibernate, la Session Factory est un composant crucial qui crée des objets Session pour gérer les connexions à la base de données et effectuer des opérations transactionnelles. Elle optimise les performances en étant coûteuse à créer et est généralement instanciée une fois par durée de vie de l'application.

Pouvez-vous expliquer comment les opérations CRUD sont exécutées dans NHibernate?

Les opérations CRUD dans NHibernate sont abstraites via l'interface `ISession`, qui fournit des méthodes telles que Save, Update et Delete. Cela permet aux développeurs d'exécuter ces opérations sans écrire directement de commandes SQL.

Quels sont les avantages d'utiliser NHibernate pour les développeurs .NET?

NHibernate bénéficie aux développeurs .NET en réduisant la quantité de code standard nécessaire pour les couches d'accès aux données, améliorant ainsi la maintenabilité des applications. Il abstrait également les interactions avec la base de données, permettant aux développeurs de se concentrer davantage sur la logique métier.

Comment NHibernate prend-il en charge la portabilité des bases de données?

NHibernate prend en charge la portabilité des bases de données grâce à sa configuration de dialecte, qui lui permet de s'adapter à diverses bases de données SQL. Cela permet aux développeurs de passer d'un système de base de données à un autre avec des modifications minimales du code.

Quel est le rôle des fichiers de mappage dans NHibernate?

Les fichiers de mappage dans NHibernate, généralement des fichiers XML, définissent comment les propriétés d'une entité se mappent aux colonnes d'une table de base de données. Ils incluent des détails importants tels que les clés primaires, les noms de colonnes et les types de données, soutenant des mappages complexes comme les relations un-à-plusieurs.

Comment les transactions peuvent-elles être gérées efficacement dans NHibernate?

Les transactions dans NHibernate sont gérées à l'aide de l'interface `ITransaction`, qui assure l'intégrité des données. Les développeurs peuvent utiliser la méthode BeginTransaction de `ISession` pour gérer les opérations, en validant les données uniquement si toutes les opérations réussissent, ou en annuler si des problèmes surviennent.

Comment configurer NHibernate dans un projet .NET?

Pour configurer NHibernate, installez le package NHibernate via le gestionnaire de packages NuGet de Visual Studio à l'aide de la commande Install-Package NHibernate. Configurez-le avec un fichier de mappage XML tel que `hibernate.cfg.xml` pour définir les paramètres de base de données et les mappages d'objets.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit