/// <summary>
/// Traverse entity graph
/// </summary>
/// <param name="entity">Entity to traverse</param>
void Traverse(IObjectWithChangeTracker entity)
{
Type type = entity.GetType();
//recover all navigation properties 1:0..1
IEnumerable <PropertyInfo> properties = from pInfo in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
where typeof(IObjectWithChangeTracker).IsAssignableFrom(pInfo.PropertyType)
select pInfo;
properties.ToList().ForEach(p => Visit((IObjectWithChangeTracker)p.GetValue(entity, null)));
//recover all navigation properties for many associations
properties = from pInfo in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
where typeof(ICollection).IsAssignableFrom(pInfo.PropertyType)
select pInfo;
properties.ToList().ForEach(p =>
{
IEnumerable enumerable = (IEnumerable)p.GetValue(entity, null);
if (enumerable != null)
{
enumerable.OfType <IObjectWithChangeTracker>().ToList().ForEach(e => Visit(e));
}
});
}
/// <summary>
/// Marque l'entité comme nouvelle.
/// </summary>
/// <param name="entity">L'entité.</param>
private void MarkAsAdded(IObjectWithChangeTracker entity)
{
entity.ChangeTracker = new ObjectChangeTracker
{
State = ObjectState.Added
};
}
public static void StopTracking(this IObjectWithChangeTracker trackingItem)
{
if (trackingItem == null)
{
throw new ArgumentNullException("trackingItem");
}
trackingItem.ChangeTracker.ChangeTrackingEnabled = false;
}
public static void AcceptChanges(this IObjectWithChangeTracker trackingItem)
{
if (trackingItem == null)
{
throw new ArgumentNullException("trackingItem");
}
trackingItem.ChangeTracker.AcceptChanges();
}
/// <summary>
/// Visti entity and traverse it
/// </summary>
/// <param name="entity">Entity to visit</param>
void Visit(IObjectWithChangeTracker entity)
{
if (entity != null &&
!_items.Contains(entity))
{
_items.Add(entity);
Traverse(entity);
}
}
public static void CancelChanges(this IObjectWithChangeTracker trackingItem)
{
if (trackingItem == null)
{
throw new ArgumentNullException("trackingItem");
}
trackingItem.ChangeTracker.CancelChanges(trackingItem);
trackingItem.NotifyMarkedAsPropertyChanged();
}
// Resets the ObjectChangeTracker to the Unchanged state and
// sets the actual values to be the original values as well as the record of changes
// to collection properties
public void CancelChanges(IObjectWithChangeTracker entity)
{
if (this.State == ObjectState.Added)
{
return;
}
OnObjectStateChanging(ObjectState.Unchanged);
ChangeTrackingEnabled = false;
ModifiedValues.Clear();
var originalValues = OriginalValues.ToArray();
foreach (var kvp in originalValues)
{
string propertyName = kvp.Key;
object propertyValue = kvp.Value;
entity.SetPropertyValue(propertyName, propertyValue);
}
var objectsAddedToCollectionProperties = ObjectsAddedToCollectionProperties.ToArray();
foreach (var kvp in objectsAddedToCollectionProperties)
{
var propertyName = kvp.Key;
var items = kvp.Value;
foreach (var item in items.ToArray())
{
entity.RemoveItemFromCollection(propertyName, item);
}
}
ObjectsAddedToCollectionProperties.Clear();
var objectsRemovedFromCollectionProperties = ObjectsRemovedFromCollectionProperties.ToArray();
foreach (var kvp in objectsRemovedFromCollectionProperties)
{
var propertyName = kvp.Key;
var items = kvp.Value;
foreach (var item in items.ToArray())
{
entity.AddItemToCollection(propertyName, item);
}
}
ObjectsRemovedFromCollectionProperties.Clear();
ChangeTrackingEnabled = true;
_objectState = ObjectState.Unchanged;
}
/// <summary>
/// Désenregistre l'élément au changement d'état.
/// </summary>
/// <param name="item">L'élément à désabonner.</param>
protected void UnregisterToStateChanged(IObjectWithChangeTracker item)
{
if (item != null)
{
if (_toUnregister == null)
{
_toUnregister = new List <IObjectWithChangeTracker>();
}
item.ChangeTracker.ObjectStateChanging -= new EventHandler <ObjectStateChangingEventArgs>(OnEntityObjectStateChanging);
_toUnregister.Remove(item);
}
}
/// <summary>
/// Rejects changes made by user
/// </summary>
/// <param name="param">Object implementing IObjectWithChangeTracker interface</param>
public static void RejectChanges(this IObjectWithChangeTracker param)
{
OriginalValuesDictionary ovd = param.ChangeTracker.OriginalValues;
PropertyInfo[] propertyInfos = (param.GetType()).GetProperties();
foreach (KeyValuePair <string, object> pair in ovd)
{
foreach (PropertyInfo property in propertyInfos)
{
if (property.Name == pair.Key && property.CanWrite)
{
property.SetValue(param, pair.Value, null);
}
}
}
}
/// <summary>
/// Enregistre l'élément au changement d'état.
/// </summary>
/// <param name="item">L'élément à abonner.</param>
protected void RegisterToStateChanged(IObjectWithChangeTracker item)
{
if (item != null)
{
if (_toUnregister == null)
{
_toUnregister = new List <IObjectWithChangeTracker>();
}
item.ChangeTracker.ObjectStateChanging += new EventHandler <ObjectStateChangingEventArgs>(OnEntityObjectStateChanging);
if (!_toUnregister.Contains(item))
{
_toUnregister.Add(item);
}
}
}
/// <summary>
/// Remet l'état de l'entité à zéro.
/// Supprime toutes les valeurs et désactive la mise à jour.
/// </summary>
public void Reset(IObjectWithChangeTracker entity)
{
var values = entity.GetCurrentValues();
foreach (var kvp in values)
{
string propertyName = kvp.Key;
object value = kvp.Value;
if (value != null)
{
var type = value.GetType();
var defaultValue = type.IsValueType ? Activator.CreateInstance(type) : null;
entity.SetPropertyValue(propertyName, defaultValue);
}
}
entity.AcceptChanges();
entity.StopTracking();
}
/// <summary>
/// Enregistre l'élément au changement d'état.
/// </summary>
/// <param name="previousItem">L'élément précédent à désabonner.</param>
/// <param name="newItem">Le nouvel élément à abonner.</param>
protected void RegisterToStateChanged(IObjectWithChangeTracker previousItem, IObjectWithChangeTracker newItem)
{
UnregisterToStateChanged(previousItem);
RegisterToStateChanged(newItem);
}
private void ShowValueDifferentError(string rule, IObjectWithChangeTracker obj, string propertyName, object value1, object value2)
{
_testContext.WriteLine("Règle : {0}. Sur l'objet {1}, la valeur de la propriété {2} vaut '{3}' et '{4}'",
rule, obj, propertyName, value1, value2);
}
/// <summary>
/// Appelé lorsqu'un élément est désabonné du changement d'état lors du Cleanup du VM.
/// </summary>
/// <param name="item">L'élément.</param>
protected virtual void OnItemUnregisteredToStateChangedOnCleanup(IObjectWithChangeTracker item)
{
}
/// <summary>
/// Accept all changes in all entities associated with <paramref name="entity"/>
/// </summary>
/// <param name="entity">Root entity</param>
public static void AcceptAllChanges(this IObjectWithChangeTracker entity)
{
using (ChangeTrackerIterator iterator = ChangeTrackerIterator.Create(entity))
iterator.Execute(ste => ste.AcceptChanges());
}
/// <summary>
/// Stop tracking in all entities associated with <paramref name="entity"/>
/// </summary>
/// <param name="entity">Root entity</param>
public static void StopTrackingAll(this IObjectWithChangeTracker entity)
{
using (ChangeTrackerIterator iterator = ChangeTrackerIterator.Create(entity))
iterator.Execute(ste => ste.StopTracking());
}
private void ShowValueDifferentError(IObjectWithChangeTracker obj, object[] values1, object[] values2, int propertyIndex)
{
System.Diagnostics.Debug.WriteLine("Sur l'objet {0}, la valeur de la propriété {1} vaut '{2}' et '{3}'",
obj, obj.GetCurrentValues().Keys.ElementAt(propertyIndex), values1[propertyIndex], values2[propertyIndex]);
}
/// <summary> /// S'assure que le tracking est activé pour l'entité spécifiée. /// </summary> /// <param name="entity">L'entité.</param> private static void EnsureTracking(IObjectWithChangeTracker entity) => entity.StartTracking();
