public void CanConfigureAbstractClass()
{
IObjectChangeTrackingConfiguration config = ObjectChangeTracking.CreateConfiguration();
config.TrackTypesFromAssembly(typeof(ConfigurationTest).GetTypeInfo().Assembly, searchSettings: new TypeSearchSettings
{
Mode = TypeSearchMode.AttributeConfigurationOnly,
/*Filter = t => t == typeof(AbstractClass) || t == typeof(DerivesAbstractClass),*/
Recursive = true
});
ITrackableObjectFactory factory = config.CreateTrackableObjectFactory();
var x = factory.CreateFrom(new DerivesAbstractClass());
}
public void CanConfigureClassWithMultipleConstructors()
{
IObjectChangeTrackingConfiguration config = ObjectChangeTracking.CreateConfiguration();
config.TrackTypesFromAssembly(typeof(ConfigurationTest).GetTypeInfo().Assembly, searchSettings: new TypeSearchSettings
{
Mode = TypeSearchMode.AttributeConfigurationOnly,
Filter = t => t == typeof(WithMultipleConstructors)
});
ITrackableObjectFactory factory = config.CreateTrackableObjectFactory();
WithMultipleConstructors instance = factory.CreateFrom(new WithMultipleConstructors());
Assert.IsNotNull(instance);
}
public void CanConfigureClassWithReadOnlyProperties()
{
IObjectChangeTrackingConfiguration config = ObjectChangeTracking.CreateConfiguration();
config.TrackTypesFromAssembly(typeof(ConfigurationTest).GetTypeInfo().Assembly, searchSettings: new TypeSearchSettings
{
Mode = TypeSearchMode.AttributeConfigurationOnly,
Filter = t => t == typeof(ClassWithReadOnlyProperties)
});
ITrackableObjectFactory factory = config.CreateTrackableObjectFactory();
ClassWithReadOnlyProperties instance = factory.CreateFrom(new ClassWithReadOnlyProperties());
instance.Text = "hey";
IObjectChangeTracker tracker = instance.GetChangeTracker();
Assert.AreEqual(1, tracker.ChangedProperties.Count);
Assert.AreEqual(1, ((ObjectChangeTracker)tracker).PropertyTrackings.Count);
}
// TODO: Remove?
/// <summary>
/// Turns all objects into change-trackable ones found in the given sequence.
/// </summary>
/// <typeparam name="T">The type of objects</typeparam>
/// <param name="enumerable">The sequence of objects to turn into change-trackable ones</param>
/// <param name="parentObjectProperty">The collection property representing the association to some object</param>
/// <param name="parentObject">The parent object that owns the association of the collection</param>
/// <returns>The already converted objects into change-trackable ones</returns>
public static IEnumerable <T> MakeAllTrackable <T>(this IEnumerable <T> enumerable, IObjectChangeTrackingConfiguration configuration, ITrackableObjectFactory trackableObjectFactory, PropertyInfo parentObjectProperty, IChangeTrackableObject parentObject)
where T : class
{
Contract.Requires(() => enumerable != null, "Given enumerable must be a non-null reference to turn its objects into trackable ones");
Contract.Requires(() => parentObjectProperty != null, "A reference to property which holds the enumerable is mandatory");
Contract.Requires(() => parentObject != null, "The instance of the object where the property holding the enumerable is declared is mandatory");
Contract.Requires(() => parentObjectProperty.DeclaringType.GetActualTypeIfTrackable().IsAssignableFrom(parentObject.GetActualTypeIfTrackable()), "Given property holding the enumerable must be declared on the given parent object type");
if (enumerable.Count() > 0 &&
configuration.CanTrackType(enumerable.First().GetType()))
{
List <T> result = new List <T>();
foreach (T item in enumerable)
{
IChangeTrackableObject trackableObject = item as IChangeTrackableObject;
if (trackableObject == null)
{
trackableObject = (IChangeTrackableObject)trackableObjectFactory.CreateFrom(item);
trackableObject.PropertyChanged += (sender, e) =>
parentObject.RaisePropertyChanged(parentObject, parentObjectProperty.Name);
}
result.Add((T)trackableObject);
}
Contract.Assert(() => result.Count == enumerable.Count(), "New sequence with objects turned into trackable ones must match the count of source sequence");
return(result);
}
else
{
return(enumerable);
}
}
public void PerfTest(int n, int m)
{
var class0 = new Class0
{
Class1 = new Class1
{
Class2s = new HashSet <Class2>(
Enumerable.Range(0, m).Select(i => new Class2 {
Number = i
})
)
}
};
var proxyList = new List <Class0>();
for (int i = 0; i < n; ++i)
{
var proxy = _trackableObjectFactory.CreateFrom(class0);
proxyList.Add(proxy);
}
Assert.AreEqual(proxyList.Count, n);
}
