Comment désactiver NHibernate automatique (dirty checking) mise à jour de comportement?

Ma solution:

1. Dans votre premier ISession création, (quelque part à l'intérieur de votre injection cadre de l'enregistrement jeu de DefaultReadOnly de vrai.
2. Dans votre IRepository de mise en œuvre qui s'enroule autour de NHibernate et gère le ISession et, dans l'instruction Insert, Update, InsertUpdate et de Supprimer (ou similaire), les méthodes qui appellent ISession.Enregistrer, mettre à Jour, SaveUpdate, etc., appel SetReadOnly pour l'entité et que l'indicateur a la valeur false.

Nous l'avons fait en utilisant les Écouteurs d'Événement avec NH (Ce n'est pas mon travail mais je ne trouve pas le lien où je l'ai fait...).

Nous avons un EventListener pour lors de la lecture dans les données, pour le définir comme ReadOnly - et puis, un pour Enregistrer (et SaveOrUpdate) pour les mettre en tant que chargé, donc que objet persistent lorsque nous avons manuellement appel Save() sur elle.

Que - ou vous pouvez utiliser un IStatelessSession qui n'a pas d'État/ChangeTracking.

Cela définit l'entité/item en ReadOnly immédiatement sur le chargement.

Je ne l'ai inclus un événement d'Insertion de l'auditeur, mais ma config références de code tous.

///<summary>
///A listener that once an object is loaded will change it's status to ReadOnly so that
///it will not be automatically saved by NH
///</summary>
///<remarks>
///For this object to then be saved, the SaveUpdateEventListener is to be used.
///</remarks>
public class PostLoadEventListener : IPostLoadEventListener
{
    public void OnPostLoad(PostLoadEvent @event)
    {
        EntityEntry entry = @event.Session.PersistenceContext.GetEntry(@event.Entity);

        entry.BackSetStatus(Status.ReadOnly);
    }
}

Sur la sauvegarde de l'objet, nous appelons cela de définir l'objet de Chargé (ce qui signifie qu'il sera désormais persistent)

public class SaveUpdateEventListener : ISaveOrUpdateEventListener
{
    public static readonly CascadingAction ResetReadOnly = new ResetReadOnlyCascadeAction();

    ///<summary>
    ///Changes the status of any loaded item to ReadOnly.
    ///</summary>
    ///<remarks>
    ///Changes the status of all loaded entities, so that NH will no longer TrackChanges on them.
    ///</remarks>
    public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
    {
        var session = @event.Session;
        EntityEntry entry = session.PersistenceContext.GetEntry(@event.Entity);

        if (entry != null && entry.Persister.IsMutable && entry.Status == Status.ReadOnly)
        {
            entry.BackSetStatus(Status.Loaded);
            CascadeOnUpdate(@event, entry.Persister, @event.Entry);
        }
    }

    private static void CascadeOnUpdate(SaveOrUpdateEvent @event, IEntityPersister entityPersister, 
        object entityEntry)
    {
        IEventSource source = @event.Session;
        source.PersistenceContext.IncrementCascadeLevel();
        try
        {
            new Cascade(ResetReadOnly, CascadePoint.BeforeFlush, source).CascadeOn(entityPersister, entityEntry);
        }
        finally
        {
            source.PersistenceContext.DecrementCascadeLevel();
        }
    }
}

Et nous de mettre en œuvre dans NH donc:

    public static ISessionFactory CreateSessionFactory(IPersistenceConfigurer dbConfig, Action<MappingConfiguration> mappingConfig, bool enabledChangeTracking,bool enabledAuditing, int queryTimeout)
{
return Fluently.Configure()
.Database(dbConfig)
.Mappings(mappingConfig)
.Mappings(x => x.FluentMappings.AddFromAssemblyOf<__AuditEntity>())
.ExposeConfiguration(x => Configure(x, enabledChangeTracking, enabledAuditing,queryTimeout))
.BuildSessionFactory();
}
///<summary>
///Configures the specified config.
///</summary>
///<param name="config">The config.</param>
///<param name="enableChangeTracking">if set to <c>true</c> [enable change tracking].</param>
///<param name="queryTimeOut">The query time out in minutes.</param>
private static void Configure(NHibernate.Cfg.Configuration config, bool enableChangeTracking, bool enableAuditing, int queryTimeOut)
{
config.SetProperty(NHibernate.Cfg.Environment.Hbm2ddlKeyWords, "none");
if (queryTimeOut > 0)
{
config.SetProperty("command_timeout", (TimeSpan.FromMinutes(queryTimeOut).TotalSeconds).ToString());
}
if (!enableChangeTracking)
{
config.AppendListeners(NHibernate.Event.ListenerType.PostLoad, new[] { new Enact.Core.DB.NHib.Listeners.PostLoadEventListener() });
config.AppendListeners(NHibernate.Event.ListenerType.SaveUpdate, new[] { new Enact.Core.DB.NHib.Listeners.SaveUpdateEventListener() });
config.AppendListeners(NHibernate.Event.ListenerType.PostUpdate, new[] { new Enact.Core.DB.NHib.Listeners.PostUpdateEventListener() });
config.AppendListeners(NHibernate.Event.ListenerType.PostInsert, new[] { new Enact.Core.DB.NHib.Listeners.PostInsertEventListener() });
}
}