C# 我们正在被处决。 <hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" namespace="ParentEntity" assembly="ParentEntity">

我们正在被处决。

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
    namespace="ParentEntity" 
    assembly="ParentEntity">

  <class name="ParentEntity" table="ParentEntity">

    <id name="Id" column="ParentEntityId" unsaved-value="-1">
      <generator class="identity"/>
    </id>

    <bag name="addresses" access="field" inverse="true" cascade="all-delete-orphan" where="IsDeleted = 0">
      <key column="ParentEntityId"/>
      <one-to-many class="Address"/>
    </bag>

  </class>

</hibernate-mapping>

public class ParentEntity : IEntity<ParentEntity>, IAuditableEntity, IDeletableEntity
{

    private ICollection<Address> addresses;


    protected ParentEntity()
    {
        addresses = new List<Address>();

    }



    public virtual ICollection<Address> Addresses
    {
        get
        {
            return new List<Address>(addresses.Where(a => !a.IsDeleted && !a.Validity.IsExpired)).AsReadOnly();
        }
        private set
        {
            addresses = value;
        }
    }

    public virtual ICollection<Address> ExpiredAddresses
    {
        get
        {
            return new List<Address>(addresses.Where(a => !a.IsDeleted && a.Validity.IsExpired)).AsReadOnly();
        }
    }



    #region IAuditableEntity Members

    public virtual EntityTimestamp Timestamp
    {
        get { return timestamp; }
        set { timestamp = value; }
    }

    #endregion


    public virtual bool AddAddress(Address address)
    {
        if (addresses.Contains(address) || ExpiredAddresses.Contains(address) )
            return false;

        address.ParentEntity = this;

        addresses.Add(address);

        return true;
    }

    public virtual bool RemoveAddress(Address address)
    {
        if (!addresses.Contains(address) && !ExpiredAddresses.Contains(address))
            return false;

        address.IsDeleted = true;
        return true;
    }

}

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
    namespace="..." 
    assembly="...">

  <class name="Address" table="Address">

    <id name="Id" column="AddressId" unsaved-value="-1">
      <generator class="identity"/>
    </id>

    <property name="Street" ></property>
    <property name="StreetNumber" ></property>
    <property name="PostOfficeBox" ></property>
    <property name="IsDeleted" not-null="true" ></property>    

    <many-to-one name="City" not-null="true" column="CityId" lazy="false" cascade="none" fetch="join" class="City"></many-to-one>

    <many-to-one name="Type" not-null="true" column="AddressTypeId" lazy="false" cascade="none" fetch="join" class="AddressType"></many-to-one>

    <many-to-one name="ParentEntity" not-null="true" update="false" column="ParentEntityId" lazy="false" cascade="none" fetch="join" class="ParentEntity"></many-to-one>


    <component name="Timestamp" class="EntityTimestamp">
      <property name="CreatedOn" not-null="true" />
      <component name="CreatedBy" class="User">
        <property name="Name" not-null="true" column="CreatedBy" />
      </component>
      <property name="ChangedOn" not-null="true" />
      <component name="ChangedBy" class="User">
        <property name="Name" not-null="true" column="ChangedBy" />
      </component>
    </component>

  </class>

</hibernate-mapping>

public class Address : IEntity<Address>, IAuditableEntity, IDeletableEntity
{
    // id etc...

    private EntityTimestamp timestamp;
    private City city;
    private bool isDeleted;
    private string street;
    private string postOfficeBox;
    private string streetNumber;
    private Validity validity;
    private AddressType type;
    private ParentEntity parentEntity;

    public virtual EntityTimestamp Timestamp
    {
        get { return timestamp; }
        set { timestamp = value; }
    }

    public virtual bool IsDeleted
    {
        get { return isDeleted; }
        set { isDeleted = value; }
    }

    public virtual string Street
    {
        get { return street; }
        set { street = value; }
    }

    public virtual string StreetNumber
    {
        get { return streetNumber; }
        set { streetNumber = value; }
    }

    public virtual string PostOfficeBox
    {
        get { return postOfficeBox; }
        set { postOfficeBox = value; }
    }

    public virtual City City
    {
        get { return city; }
        set { city = value; }
    }

    public virtual AddressType Type
    {
        get { return type; }
        set { type = value; }
    }

    public virtual Validity Validity
    {
        get { return validity; }
        set { validity = value; }
    }

    protected internal virtual ParentEntity ParentEntity
    {
        get { return parentEntity; }
        set { parentEntity = value; }
    }

    protected Address()
    {
    }

    public Address(Validity validity)
    {
        this.validity = validity;
    }
}

public virtual DateTime CreatedOn
{
    get { return createdOn; }
    private set { createdOn = value; }
}

private IUser createdBy;


public virtual IUser CreatedBy
{
    get { return createdBy; }
    private set { createdBy = value; }
}

private DateTime changedOn;


public virtual DateTime ChangedOn
{
    get { return changedOn; }
    private set { changedOn = value; }
}

private IUser changedBy;


public virtual IUser ChangedBy
{
    get { return changedBy; }
    private set { changedBy = value; }
}


protected EntityTimestamp()
{
}

private EntityTimestamp(DateTime createdOn, IUser createdBy, DateTime changedOn, IUser changedBy)
{
    if (createdBy == null)
        throw new ArgumentException("Created by user is null.");

    if (changedBy == null)
        throw new ArgumentException("Changed by user is null.");

    this.createdOn = createdOn;
    this.createdBy = createdBy;
    this.changedBy = changedBy;
    this.changedOn = changedOn;
}

public static EntityTimestamp New()
{            
    return new EntityTimestamp(new DateTimePrecise().Now, SecurityService.Current.GetCurrentUser(), new DateTimePrecise().Now, SecurityService.Current.GetCurrentUser());
}

public static EntityTimestamp New(IUser forUser)
{
    return new EntityTimestamp(new DateTimePrecise().Now, forUser, new DateTimePrecise().Now, forUser);
}

public static EntityTimestamp NewUpdated(IUser forUser, EntityTimestamp oldTimestamp)
{
    return new EntityTimestamp(oldTimestamp.CreatedOn, oldTimestamp.CreatedBy, new DateTimePrecise().Now, forUser);
}

public static EntityTimestamp NewUpdated(EntityTimestamp oldTimestamp)
{
    return new EntityTimestamp(oldTimestamp.CreatedOn, oldTimestamp.CreatedBy, new DateTimePrecise().Now, SecurityService.Current.GetCurrentUser());
}

public class EntitySaveEventListener : NHibernate.Event.Default.DefaultSaveEventListener
    {
        protected override object PerformSaveOrUpdate(SaveOrUpdateEvent e)
        {
            if (e.Entity is IAuditableEntity)
            {
                var entity = e.Entity as IAuditableEntity;
                //todo: CascadeBeforeSave();
                if (entity != null)
                {             
                        IsDirtyEntity(e.Session, e.Entity);       
                    if (entity.IsNew)
                    {
                        entity.Timestamp = EntityTimestamp.New();
                    }
                    else
                    {
                        entity.Timestamp = EntityTimestamp.NewUpdated(entity.Timestamp);


                    }

                }
            }

            return base.PerformSaveOrUpdate(e);
        }

public static Boolean IsDirtyEntity(ISession session, Object entity)
{
    String className = NHibernateProxyHelper.GuessClass(entity).FullName;
    ISessionImplementor sessionImpl = session.GetSessionImplementation();
    IPersistenceContext persistenceContext = sessionImpl.PersistenceContext;
    IEntityPersister persister = sessionImpl.Factory.GetEntityPersister(className);
    EntityEntry oldEntry = sessionImpl.PersistenceContext.GetEntry(entity);


    if ((oldEntry == null) && (entity is INHibernateProxy))
    {
        INHibernateProxy proxy = entity as INHibernateProxy;
        Object obj = sessionImpl.PersistenceContext.Unproxy(proxy);
        oldEntry = sessionImpl.PersistenceContext.GetEntry(obj);
    }

    Object [] oldState = oldEntry.LoadedState;
    Object [] currentState = persister.GetPropertyValues(entity, sessionImpl.EntityMode);
    Int32 [] dirtyProps = persister.FindDirty(currentState, oldState, entity, sessionImpl);

    return (dirtyProps != null);
}

              ) AS Results 
                WHERE 
                  RowNum BETWEEN (@p0 - 1) * @p1 + 1 AND @p2 * @p3
              ORDER BY 
             [Rank] DESC;@p0 = 1, @p1 = 20, @p2 = 1, @p3 = 20

public class AuditableEventListener : DefaultSaveOrUpdateEventListener, IPreUpdateEventListener
{
    public override void OnSaveOrUpdate(SaveOrUpdateEvent @event)
    {
        Auditable a = @event.Entity as Auditable;
        if (a != null)
        {
            if (this.GetEntityState(@event.Entity, @event.EntityName, @event.Entry, @event.Session) == EntityState.Transient)
            {
                a.create_dt = DateTime.Now;
                a.create_by = @event.Session.Load<Staff>(CurrentStaff.Id);
            }
        }

        base.OnSaveOrUpdate(@event);
    }

    #region IPreUpdateEventListener Members

    public bool OnPreUpdate(PreUpdateEvent @event)
    {
        var audit = @event.Entity as Auditable;
        if (audit == null) return false;

        var now = DateTime.Now;
        var user = @event.Session.Load<Staff>(CurrentStaff.Id);

        //Very important to keep the State and Entity synced together
        Set(@event.Persister, @event.State, "last_update_dt", now);
        Set(@event.Persister, @event.State, "last_update_by", user);

        audit.last_update_dt = now;
        audit.last_update_by = user;

        return false;
    }

    #endregion


    private void Set(IEntityPersister persister, object[] state, string propertyName, object value)
    {
        var index = Array.IndexOf(persister.PropertyNames, propertyName);
        if (index == -1)
            return;
        state[index] = value;
    }

}

ISaveOrUpdateEventListener[] saveUpdateListeners = new ISaveOrUpdateEventListener[] { new AuditableEventListener() };
conf.EventListeners.SaveEventListeners = saveUpdateListeners;
conf.EventListeners.SaveOrUpdateEventListeners = saveUpdateListeners;
conf.EventListeners.UpdateEventListeners = saveUpdateListeners;

conf.EventListeners.PreUpdateEventListeners = new IPreUpdateEventListener[] { new AuditableEventListener() };