private System.DateTime _date = System.DateTime.Now;
	private string _produit;
	private int _quantité;
	private int _prixTotal;

	[NHibernate.Mapping.Attributes.Property(Column="`Date`")]
	public virtual System.DateTime Date
	{
		get { return _date; }
	}

	[NHibernate.Mapping.Attributes.Property(NotNull=true)]
	public virtual string Produit
	{
		get { return _produit; }
		set { _produit = value; }
	}

	[NHibernate.Mapping.Attributes.Property]
	public virtual int Quantité
	{
		get { return _quantité; }
		set { _quantity = value; }
	}

	[NHibernate.Mapping.Attributes.Property]
	public virtual int PrixTotal
	{
		get { return _prixTotal; }
		set { _prixTotal = value; }
	}

	public Commande()
	{
	}

	public Commande(string produit, int prixUnitaire, int quantité)
	{
		this.Produit = produit;
		this.Quantité = quantité; // Ne pas utiliser _quantité
		this.CalculeLePrixTotal(prixUnitaire);
	}

	public void CalculeLePrixTotal(int prixUnitaire)
	{
		this.PrixTotal = prixUnitaire * this.Quantité;
	}

	public virtual void ChangeLeFuseauHoraire(int n)
	{
		this._date = this.Date.AddHours(n);
	}

[assembly: log4net.Config.XmlConfigurator(Watch=true)]

// Crée l'objet qui contiendras les informations de configuration
// et assigne les informations pour accéder à la base de données
NHibernate.Cfg.Configuration cfg = new NHibernate.Cfg.Configuration();
cfg.SetProperty(NHibernate.Cfg.Environment.ConnectionProvider, "NHibernate.Connection.DriverConnectionProvider");

if("Access" == baseDeDonnées)
{
	cfg.SetProperty(NHibernate.Cfg.Environment.Dialect, "NHibernate.JetDriver.JetDialect, NHibernate.JetDriver");
	cfg.SetProperty(NHibernate.Cfg.Environment.ConnectionDriver, "NHibernate.JetDriver.JetDriver, NHibernate.JetDriver");
	cfg.SetProperty(NHibernate.Cfg.Environment.ConnectionString, chaîneDeConnexion);
}
else [...]

System.IO.MemoryStream flux = new System.IO.MemoryStream(); // Contenant des informations
NHibernate.Mapping.Attributes.HbmSerializer.Default.Validate = true; // Active la validation (optionnel)
// Demande à NHibernate d'utiliser les champs et non les propriétés (dans les entités)
NHibernate.Mapping.Attributes.HbmSerializer.Default.HbmDefaultAccess = "field.camelcase-underscore";
// Récupère les informations à partir de cette assemblée (peut aussi être fait classe par classe)
System.Console.Out.WriteLine("NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize()...\n");
NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(flux,
	System.Reflection.Assembly.GetExecutingAssembly());
flux.Position = 0;
cfg.AddInputStream(flux); // Envoi les informations de Mappage à la Configuration de NHibernate
flux.Close();

new NHibernate.Tool.hbm2ddl.SchemaExport(cfg).Create(true, true);

_sessionFactory = cfg.BuildSessionFactory();

	NHibernate.ISession session = null;
	NHibernate.ITransaction transaction = null;
	try
	{
		session = _sessionFactory.OpenSession();
		transaction = session.BeginTransaction();

		// Opérations CRUD ici (avec la session)

		transaction.Commit();
	}
	catch
	{
		if(transaction != null)
			transaction.Rollback();
		throw;
	}
	finally
	{
		if(session != null)
			session.Close();
	}

	using(NHibernate.ISession session = _sessionFactory.OpenSession())
	{
		// Récupération de données ici (avec la session)
	}

	public void GénèreDesCommandesAléatoires(int n)
	{
		NHibernate.ISession session = null;
		NHibernate.ITransaction transaction = null;
	
		System.Console.Out.WriteLine("\nEnregistrement de " + n + " commandes aléatoires...");
		try
		{
			session = _sessionFactory.OpenSession();
			transaction = session.BeginTransaction();
	
			for(int i=0; i<n; i++)
			{
				Commande c = new Commande();
	
				c.Produit = "P" + (i+1).ToString();
				c.Quantité = n - i;
				c.CalculeLePrixTotal(i * 10 + n);
	
				session.Save(c);
			}
	
			// Envoie les modifications (=> Génère et exécute les requêtes)
			transaction.Commit();
		}
		catch
		{
			if(transaction != null)
				transaction.Rollback(); // Erreur => nous DEVONT annuler les modifications
			throw; // Ici, nous renvoyons la même exception pour qu'elle soit gérée (imprimée)
		}
		finally
		{
			if(session != null)
				session.Close();
		}
	}

	public void AfficheToutesLesCommandes()
	{
		using(NHibernate.ISession session = _sessionFactory.OpenSession())
		{
			System.Collections.IList résultat = session.Find("select c.Id, c.Date, c.Produit from Commande c");

			System.Console.Out.WriteLine("\n" + résultat.Count + " commandes trouvées!");
			foreach(System.Collections.IList l in résultat)
				System.Console.Out.WriteLine("  Commande N°"
					+ l[0] + ",  Date=" + ((System.DateTime)l[1]).ToString("u") + ",  Produit=" + l[2]);
		}
	}

	public Commande ChargeUneCommande(int id)
	{
		System.Console.Out.WriteLine("\nChargement de la commande N° " + id + "...");
		using(NHibernate.ISession session = _sessionFactory.OpenSession())
			return session.Load(typeof(Commande), id) as Commande;
	}

	public void Sauvegarde(Commande c)
	{
		NHibernate.ISession session = null;
		NHibernate.ITransaction transaction = null;

		// Voici comment la Session décide d'insérer ou de mettre à jour;
		// utilisez NHMA.Id(UnsavedValue=x) pour remplacer 0
		System.Console.Out.Write("\n"  +  (c.Id == 0  ?  "Insertion"  :  "Mise à jour"));
		System.Console.Out.WriteLine(" la commande N° " + c.Id + "...");
		try
		{
			session = _sessionFactory.OpenSession();
			transaction = session.BeginTransaction();

			session.SaveOrUpdate(c);

			// Envoie les modifications (=> Génère et exécute les requêtes)
			transaction.Commit();
		}
		catch
		{
			if(transaction != null)
				transaction.Rollback(); // Erreur => nous DEVONT annuler les modifications
			throw; // Ici, nous renvoyons la même exception pour qu'elle soit gérée (imprimée)
		}
		finally
		{
			if(session != null)
				session.Close();
		}
	}

	public void ChangeLeFuseauHoraire(int n)
	{
		NHibernate.ISession session = null;
		NHibernate.ITransaction transaction = null;

		System.Console.Out.WriteLine("\nChangement du fuseau horaire de toutes les commandes: n=" + n + "...");
		try
		{
			session = _sessionFactory.OpenSession();
			transaction = session.BeginTransaction();

			System.Collections.IList commandes = session.CreateCriteria(typeof(Commande)).List();
			// identique à: session.Find("from Commande");
			foreach(Commande c in commandes)
				c.ChangeLeFuseauHoraire(n);
			// Il est inutile d'appeler Update(), la Session vas automatiquement
			// détecter les entités modifiées (tant que c'est bien elle qui les a chargé)
			System.Console.Out.WriteLine(commandes.Count + " commandes modifiées!");

			// Envoie les modifications (=> Génère et exécute les requêtes)
			transaction.Commit();
		}
		catch
		{
			if(transaction != null)
				transaction.Rollback(); // Erreur => nous DEVONT annuler les modifications
			throw; // Ici, nous renvoyons la même exception pour qu'elle soit gérée (imprimée)
		}
		finally
		{
			if(session != null)
				session.Close();
		}
	}

			session.CreateCriteria(typeof(Commande)).List();
			// Equivalent à:
			session.Find("from Commande");
			// "select" n'est pas nécessaire lorsqu'on veut des entités (dans de simple requêtes)
			// mais vous pouvez écrire:
			session.Find("select c from Commande c");

	public void Détruire(int id)
	{
		NHibernate.ISession session = null;
		NHibernate.ITransaction transaction = null;

		System.Console.Out.WriteLine("\nEffacement de la commande N° " + id + "...");
		try
		{
			session = _sessionFactory.OpenSession();
			transaction = session.BeginTransaction();

			session.Delete("from Commande c where c.Id = :Id", id, NHibernate.NHibernateUtil.Int32);

			// Envoie les modifications (=> Génère et exécute les requêtes)
			transaction.Commit();
		}
		catch
		{
			if(transaction != null)
				transaction.Rollback(); // Erreur => nous DEVONT annuler les modifications
			throw; // Ici, nous renvoyons la même exception pour qu'elle soit gérée (imprimée)
		}
		finally
		{
			if(session != null)
				session.Close();
		}
	}

session.Delete("from Commande c where c.Id = " + id);