/// <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();