private static PropertyDiff[] GetPropertyDiffs(string[] propertyNames, IType[] types, object[] currentState, object[] previousState)
{
var diffs = new PropertyDiff[propertyNames.Length];
for (var i = 0; i < diffs.Length; i++)
{
var oldValue = previousState == null ? null : previousState[i];
var newValue = currentState == null ? null : currentState[i];
// need to handle collections specially
if (types[i].IsCollectionType && ReferenceEquals(oldValue, newValue))
{
// the collection instance itself has not changed, but perhaps the content has?
// if the oldValue is a persistent collection, then we can get a snapshot from
// when the collection was initially loaded, and see if it is dirty
if (oldValue is IPersistentCollection && NHibernateUtil.IsInitialized(oldValue))
{
oldValue = GetCollectionSnapshot(oldValue as IPersistentCollection);
}
}
diffs[i] = new PropertyDiff(propertyNames[i], types[i], oldValue, newValue);
}
return(diffs);
}
/// <summary>
/// Returns a new change record that represents the total of this change
/// and the previous change.
/// </summary>
/// <param name="previousChange"></param>
/// <returns></returns>
public ChangeRecord Compound(ChangeRecord previousChange)
{
// assume the propertyDiffs array in both objects is aligned
var resultDiffs = new PropertyDiff[_propertyDiffs.Length];
for (var i = 0; i < _propertyDiffs.Length; i++)
{
resultDiffs[i] = _propertyDiffs[i].Compound(previousChange.PropertyDiffs[i]);
}
// return a new change record that represents the accumulation of both changes
// the resultant ChangeType depends on whether this change Supercedes previousChange, or vice versa
return new ChangeRecord(_entity, Supercedes(previousChange) ? _changeType : previousChange._changeType, resultDiffs);
}
/// <summary>
/// Returns a new change record that represents the total of this change
/// and the previous change.
/// </summary>
/// <param name="previousChange"></param>
/// <returns></returns>
public ChangeRecord Compound(ChangeRecord previousChange)
{
// assume the propertyDiffs array in both objects is aligned
var resultDiffs = new PropertyDiff[_propertyDiffs.Length];
for (var i = 0; i < _propertyDiffs.Length; i++)
{
resultDiffs[i] = _propertyDiffs[i].Compound(previousChange.PropertyDiffs[i]);
}
// return a new change record that represents the accumulation of both changes
// the resultant ChangeType depends on whether this change Supercedes previousChange, or vice versa
return(new ChangeRecord(_entity, Supercedes(previousChange) ? _changeType : previousChange._changeType, resultDiffs));
}
/// <summary>
/// Records that the specified change occured to the specified entity.
/// </summary>
/// <param name="entity"></param>
/// <param name="changeType"></param>
/// <param name="propertyDiffs"></param>
internal void RecordChange(Entity entity, EntityChangeType changeType, PropertyDiff[] propertyDiffs)
{
var thisChange = new ChangeRecord(entity, changeType, propertyDiffs);
// check if this entity was already recorded in the list
// note that reference equality is used because we do not know how the Equals method of the entity may be implemented
// for example, it may define equality based on a property whose value has changed, which would break this logic
var prevRecordIndex = _changeRecords.FindIndex(r => ReferenceEquals(r.Entity, entity));
if (prevRecordIndex > -1)
{
// this entity was already marked as changed
var previousChange = _changeRecords[prevRecordIndex];
// compound the previous change record with this one
_changeRecords[prevRecordIndex] = thisChange.Compound(previousChange);
}
else
{
// record this change in the change set
_changeRecords.Add(thisChange);
}
}
public ChangeRecord(Entity entity, EntityChangeType changeType, PropertyDiff[] propertyDiffs)
{
_entity = entity;
_changeType = changeType;
_propertyDiffs = propertyDiffs;
}
/// <summary>
/// Returns a new <see cref="PropertyDiff"/> that is the result of adding this change
/// to <paramref name="previousChange"/>.
/// </summary>
/// <param name="previousChange"></param>
/// <returns></returns>
/// <remarks>
/// This operation is not commutative.
/// </remarks>
public PropertyDiff Compound(PropertyDiff previousChange)
{
return(new PropertyDiff(_propertyName, _hibernateType, previousChange._oldValue, _newValue));
}
/// <summary>
/// Returns a new <see cref="PropertyDiff"/> that is the result of adding this change
/// to <paramref name="previousChange"/>.
/// </summary>
/// <param name="previousChange"></param>
/// <returns></returns>
/// <remarks>
/// This operation is not commutative.
/// </remarks>
public PropertyDiff Compound(PropertyDiff previousChange)
{
return new PropertyDiff(_propertyName, _hibernateType, previousChange._oldValue, _newValue);
}
private static PropertyDiff[] GetPropertyDiffs(string[] propertyNames, IType[] types, object[] currentState, object[] previousState)
{
var diffs = new PropertyDiff[propertyNames.Length];
for (var i = 0; i < diffs.Length; i++)
{
var oldValue = previousState == null ? null : previousState[i];
var newValue = currentState == null ? null : currentState[i];
// need to handle collections specially
if (types[i].IsCollectionType && ReferenceEquals(oldValue, newValue))
{
// the collection instance itself has not changed, but perhaps the content has?
// if the oldValue is a persistent collection, then we can get a snapshot from
// when the collection was initially loaded, and see if it is dirty
if (oldValue is IPersistentCollection && NHibernateUtil.IsInitialized(oldValue))
{
oldValue = GetCollectionSnapshot(oldValue as IPersistentCollection);
}
}
diffs[i] = new PropertyDiff(propertyNames[i], types[i], oldValue, newValue);
}
return diffs;
}
private void RecordChange(object domainObject, EntityChangeType changeType, PropertyDiff[] propertyDiffs)
{
if(IsChangeSetPublishable((DomainObject)domainObject))
{
// update all change trackers
var entity = (Entity)domainObject;
foreach (var changeTracker in _changeTrackers)
{
changeTracker.RecordChange(entity, changeType, propertyDiffs);
}
}
}
