public static void Unregister(this IObjectExtender <object> obj, string eventName)
{
var instance = obj.Instance;
if (!instancesEventsDictionary.ContainsKey(instance))
{
return;
}
if (!instancesEventsDictionary[instance].ContainsKey(eventName))
{
return;
}
var type = instance.GetType();
var eventObj = type.GetEvent(eventName);
var message = $"The type {type.Name} does not contain an event with the specified name {eventName}.";
var delegateObj = instancesEventsDictionary[instance][eventName];
eventObj.RemoveEventHandler(instance, delegateObj);
instancesEventsDictionary[instance].Remove(eventName);
if (instancesEventsDictionary[instance].Count == 0)
{
instancesEventsDictionary.Remove(instance);
}
}
private static IEnumerable <object> GetFlatternChildren <T>(
this IObjectExtender <T> root, ICollection <object> list, Predicate <Type> predicate)
{
var instance = root.Instance;
if (list.Contains(instance))
{
return(Enumerable.Empty <object>());
}
const BindingFlags InstanceMembers = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
var properties = instance.GetType().GetProperties(InstanceMembers);
var fields = instance.GetType().GetFields(InstanceMembers);
var filteredProperties =
properties
.Where(item => predicate(item.PropertyType))
.Select(item => item.GetValue(instance, null))
.SelectMany(item => item.Extend().GetEnumerable())
.Where(item => item != null && !item.Equals(instance));
var filteredFields =
fields
.Where(item => predicate(item.FieldType))
.Select(item => item.GetValue(instance))
.SelectMany(item => item.Extend().GetEnumerable())
.Where(item => item != null && !item.Equals(instance));
AddChildren(list, predicate, filteredProperties);
AddChildren(list, predicate, filteredFields);
return(list);
}
public BuildUpObjectBuilder(object instance, IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender)
{
this.instance = instance;
this.instanceType = instance.GetType();
this.containerExtensionManager = containerExtensionManager;
this.objectExtender = objectExtender;
this.containerContext = containerContext;
}
public static void OnTrueExecute(this IObjectExtender <bool> value, Action action)
{
if (!value.Instance)
{
return;
}
action();
}
public static void OnNotDefault <T>(this IObjectExtender <T> obj, Action <T> action) where T : class
{
var instance = obj.Instance;
if (instance.IsDefault())
{
return;
}
action(instance);
}
public ExtendedPropertyDescriptor(PropertyDescriptor descriptor, object component)
: base(descriptor)
{
IObjectExtender objectExtender = component as IObjectExtender;
if (objectExtender != null)
{
element = objectExtender.ModelElement;
}
this.descriptor = descriptor;
this.instance = component;
}
/// <summary>
/// Creates the object extender.
/// </summary>
/// <param name="extensionProvider">The extension provider.</param>
/// <returns></returns>
public object CreateObjectExtender(Extension.IExtensionProvider extensionProvider, ModelElement modelElement)
{
Guard.ArgumentNotNull(extensionProvider, "extensionProvider");
Type objectExtenderType = GetObjectExtenderType(extensionProvider, this.extensibleObject.GetType());
if (objectExtenderType == null)
{
return(null);
}
if (extensibleObject.ObjectExtenderContainer == null)
{
CreateObjectExtenderContainer();
}
IObjectExtender objectExtender = GetObjectExtender(extensionProvider) as IObjectExtender;
// reset container to avoid cloning containers on copy/paste operations
if (objectExtender != null &&
objectExtender.ModelElement != null &&
objectExtender.ModelElement != modelElement)
{
CreateObjectExtenderContainer();
objectExtender = null;
}
if (objectExtender == null)
{
try
{
objectExtender = Activator.CreateInstance(objectExtenderType) as IObjectExtender;
this.extensibleObject.ObjectExtenderContainer.ObjectExtenders.Add(objectExtender);
}
catch (Exception ex)
{
Logger.Write(ex);
}
}
if (objectExtender.ModelElement == null)
{
IObjectExtenderInternal objectExtenderInternal = objectExtender as IObjectExtenderInternal;
if (objectExtenderInternal != null)
{
objectExtenderInternal.ModelElement = modelElement;
}
}
return(objectExtender);
}
public static IEnumerable <object> GetEnumerable <T>(this IObjectExtender <T> obj)
{
var collection = obj.Instance as IEnumerable;
if (collection == null)
{
yield return(obj);
yield break;
}
foreach (var item in collection)
{
yield return(item);
}
}
public static TEventHandler Register <TEventHandler>(this IObjectExtender <object> obj, TEventHandler action)
{
var instance = obj.Instance;
var eventType = typeof(TEventHandler);
var eventName =
instance
.GetType()
.GetEvents()
.Single(eventObj => eventObj.EventHandlerType == eventType).Name;
if (!instancesEventsDictionary.ContainsKey(obj))
{
instancesEventsDictionary
.Add(instance, new Dictionary <string, Delegate>());
}
var eventDictionary = instancesEventsDictionary[instance];
eventDictionary.Add(eventName, (Delegate)(object)action);
return(action);
}
public static IEnumerable <object> GetFlatternChildren <T>(this IObjectExtender <T> root, Predicate <Type> predicate)
{
return(GetFlatternChildren(root, new HashSet <object>(), predicate));
}
public static IEnumerable <object> GetFlatternChildren <T>(this IObjectExtender <T> root)
where T : class
{
return(GetFlatternChildren(root, type => type.IsPrimitiveType() || type.IsEnumerableOf <T>()));
}
private FactoryObjectBuilder(IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender)
{
this.containerExtensionManager = containerExtensionManager;
this.objectExtender = objectExtender;
this.containerContext = containerContext;
}
public FactoryObjectBuilder(Func<object, object, object, object> threeParamsFactory, IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender)
: this(containerContext, containerExtensionManager, objectExtender)
{
this.threeParamsFactory = threeParamsFactory;
}
public FactoryObjectBuilder(Func<object> factory, IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender)
: this(containerContext, containerExtensionManager, objectExtender)
{
this.singleFactory = factory;
}
public static bool HasHandlers(this IObjectExtender <object> obj)
{
return(instancesEventsDictionary.ContainsKey(obj.Instance));
}
