/// <summary>
/// Gets the types defined in this assembly.
/// </summary>
public static IList <Type> SafeGetTypes(this Assembly assembly, bool throwOnError)
{
try
{
var func = GetTypesDefault;
if (func != null)
{
return(func(assembly));
}
#if PCL_WINRT
return(assembly.DefinedTypes.Select(info => info.AsType()).ToList());
#else
return(assembly.GetTypes());
#endif
}
catch (ReflectionTypeLoadException e)
{
if (throwOnError)
{
throw;
}
Tracer.Error("SafeGetTypes {0} - error {1}", assembly.FullName, e.Flatten(true));
}
return(Empty.Array <Type>());
}
public static string GenerateRestorationIdentifier(object item, bool checkRestoreMethodOverload)
{
Type type = item.GetType();
int value;
lock (TypeToCounters)
{
if (!TypeToCounters.TryGetValue(type, out value))
{
if (typeof(UIViewController).IsAssignableFrom(type) || typeof(UIView).IsAssignableFrom(type))
{
var method = type.GetMethod("EncodeRestorableState", BindingFlags.Public | BindingFlags.Instance,
null, CoderParameters, Empty.Array <ParameterModifier>());
if (method != null && (method.DeclaringType == typeof(UIViewController) || method.DeclaringType == typeof(UIView)))
{
value = int.MinValue;
TypeToCounters[type] = value;
}
}
}
if (checkRestoreMethodOverload && value < 0)
{
Tracer.Warn("The item '{0}' not support the preservation of the state since it does not have overloaded methods (EncodeRestorableState, DecodeRestorableState).",
type.Name);
return(null);
}
TypeToCounters[type] = value + 1;
}
return(type.AssemblyQualifiedName + "~" + value.ToString(CultureInfo.InvariantCulture));
}
private IList <object> GetAll(Type service, string name = null, params IIocParameter[] parameters)
{
Should.NotBeNull(service, nameof(service));
var key = new BindingKey(service, name);
List <BindingRegistration> registrations;
lock (_bindingRegistrations)
_bindingRegistrations.TryGetValue(key, out registrations);
if (registrations != null && registrations.Count > 0)
{
var result = new object[registrations.Count];
for (int i = 0; i < registrations.Count; i++)
{
result[i] = registrations[i].Resolve(parameters);
}
return(result);
}
if (_parent != null && _parent.HasRegistration(key))
{
return(_parent.GetAll(service, name, parameters));
}
object value;
if (TryResolve(service, parameters, out value))
{
return new[] { value }
}
;
return(Empty.Array <object>());
}
protected virtual IList <IModule> GetModules(IList <Assembly> assemblies)
{
if (Mode == LoadMode.Design)
{
return(Empty.Array <IModule>());
}
return(assemblies.GetModules(true));
}
private static IList <IIocParameter> GetParameters(IContext context)
{
if (context.Parameters == null || context.Parameters.Count == 0)
{
return(Empty.Array <IIocParameter>());
}
var parameterContainer = context.Parameters.OfType <ParameterContainer>().FirstOrDefault();
if (parameterContainer == null)
{
return(Empty.Array <IIocParameter>());
}
return(parameterContainer.Parameters);
}
private static IList <IIocParameter> GetParameters(IEnumerable <Parameter> parameters)
{
if (parameters == null)
{
return(Empty.Array <IIocParameter>());
}
var parameterContainer = parameters.OfType <ParameterContainer>().FirstOrDefault();
if (parameterContainer == null)
{
return(Empty.Array <IIocParameter>());
}
return(parameterContainer.Parameters);
}
private IList <IIocParameter> MergeParameters(IList <IIocParameter> parameters)
{
if (_parameters == null || _parameters.Length == 0)
{
return(parameters ?? Empty.Array <IIocParameter>());
}
if (parameters == null || parameters.Count == 0)
{
return(_parameters ?? Empty.Array <IIocParameter>());
}
var iocParameters = new List <IIocParameter>(parameters);
iocParameters.AddRange(_parameters);
return(iocParameters);
}
/// <summary>
/// Converts parameters.
/// </summary>
protected IParameter[] ConvertParameters(IList <IIocParameter> parameters)
{
if (parameters == null || parameters.Count == 0)
{
return(Empty.Array <IParameter>());
}
var list = new List <IParameter>();
foreach (var iocParameter in parameters)
{
list.AddIfNotNull(ConvertParameter(iocParameter));
}
list.Add(new ParameterContainer(parameters));
return(list.ToArrayEx());
}
/// <summary>
/// Determines whether the specified request can be resolved.
/// </summary>
/// <param name="service">The specified service type.</param>
/// <param name="name">The specified binding name.</param>
/// <returns>
/// <c>True</c> if the specified service has been resolved; otherwise, <c>false</c>.
/// </returns>
public bool CanResolve(Type service, string name = null)
{
Should.NotBeNull(service, "service");
if (IsDisposed)
{
return(false);
}
Func <IBindingMetadata, bool> canResolve = null;
if (name != null)
{
canResolve = metadata => metadata.Name == name;
}
IRequest req = _kernel.CreateRequest(service, canResolve, Empty.Array <IParameter>(), false, true);
return(_kernel.CanResolve(req, true));
}
public void BindToMethod(Type service, Func <IIocContainer, IList <IIocParameter>, object> methodBindingDelegate, DependencyLifecycle lifecycle, string name = null, params IIocParameter[] parameters)
{
this.NotBeDisposed();
Should.NotBeNull(service, "service");
Should.NotBeNull(methodBindingDelegate, "methodBindingDelegate");
if (parameters == null)
{
parameters = Empty.Array <IIocParameter>();
}
IMethodCallbackObjectPriorityUseWithSyntax syntax = _injector.BindWithManualBuild(service).ToMethod(context => methodBindingDelegate(this, GetParameters(parameters, context))).InScope(GetScope(lifecycle));
if (name != null)
{
syntax.NamedBinding(name);
}
syntax.Build();
}
public void BindToMethod(Type service, Func <IIocContainer, IList <IIocParameter>, object> methodBindingDelegate, DependencyLifecycle lifecycle, string name = null, params IIocParameter[] parameters)
{
this.NotBeDisposed();
Should.NotBeNull(service, "service");
Should.NotBeNull(methodBindingDelegate, "methodBindingDelegate");
if (parameters == null)
{
parameters = Empty.Array <IIocParameter>();
}
var builder = new ContainerBuilder();
IRegistrationBuilder <object, SimpleActivatorData, SingleRegistrationStyle> syntax = name == null
? builder.Register((context, args) => methodBindingDelegate(this, GetParameters(parameters, args))).As(service)
: builder.Register((context, args) => methodBindingDelegate(this, GetParameters(parameters, args))).Named(name, service);
SetLifetimeScope(lifecycle, syntax.RegistrationData);
builder.Update(_container.ComponentRegistry);
}
internal static void DisposeCommands(IViewModel item)
{
Should.NotBeNull(item, nameof(item));
Func <object, ICommand>[] list;
lock (TypesToCommandsProperties)
{
Type type = item.GetType();
if (!TypesToCommandsProperties.TryGetValue(type, out list))
{
List <Func <object, ICommand> > items = null;
foreach (var p in type.GetPropertiesEx(PropertyBindingFlag))
{
if (typeof(ICommand).IsAssignableFrom(p.PropertyType) && p.CanRead &&
p.GetIndexParameters().Length == 0)
{
var func = ServiceProvider.ReflectionManager.GetMemberGetter <ICommand>(p);
if (items == null)
{
items = new List <Func <object, ICommand> >();
}
items.Add(func);
}
}
list = items == null?Empty.Array <Func <object, ICommand> >() : items.ToArray();
TypesToCommandsProperties[type] = list;
}
}
if (list.Length == 0)
{
return;
}
for (int index = 0; index < list.Length; index++)
{
try
{
(list[index].Invoke(item) as IDisposable)?.Dispose();
}
catch (Exception)
{
//To avoid method access exception.
}
}
}
public void BindToMethod(Type service, Func <IIocContainer, IList <IIocParameter>, object> methodBindingDelegate,
DependencyLifecycle lifecycle, string name = null, params IIocParameter[] parameters)
{
this.NotBeDisposed();
Should.NotBeNull(service, nameof(service));
Should.NotBeNull(methodBindingDelegate, nameof(methodBindingDelegate));
if (parameters == null)
{
parameters = Empty.Array <IIocParameter>();
}
IBindingWhenInNamedWithOrOnSyntax <object> syntax = _kernel
.Bind(service)
.ToMethod(context => methodBindingDelegate(this, GetParameters(parameters, context)));
SetLifecycle(syntax, lifecycle);
if (name != null)
{
syntax.Named(name);
}
}
private static object DefaultEntityFactoryMethod(Type type)
{
Should.NotBeNull(type, "type");
ConstructorInfo constructor;
lock (EntityConstructorInfos)
{
if (!EntityConstructorInfos.TryGetValue(type, out constructor))
{
constructor = type.GetConstructor(Empty.Array <Type>());
EntityConstructorInfos[type] = constructor;
}
}
if (constructor == null)
{
MugenMvvmToolkit.Tracer.Warn("Cannot create default entity no default constructor exists for class {0}", type);
return(null);
}
return(constructor.InvokeEx(Empty.Array <object>()));
}
/// <summary>
/// Gets the modules.
/// </summary>
public static IList <IModule> GetModules([NotNull] this IEnumerable <Assembly> assemblies, bool throwOnError)
{
Should.NotBeNull(assemblies, "assemblies");
var modulesToLoad = new List <Type>();
foreach (var assembly in SkipFrameworkAssemblies(assemblies.Distinct()))
{
foreach (var type in assembly.SafeGetTypes(throwOnError))
{
if (typeof(IModule).IsAssignableFrom(type) && type.IsPublicNonAbstractClass())
{
modulesToLoad.Add(type);
}
}
}
var modules = new List <IModule>();
for (int index = 0; index < modulesToLoad.Count; index++)
{
Type moduleType = modulesToLoad[index];
var constructor = moduleType.GetConstructor(Empty.Array <Type>());
#if PCL_WINRT
if (constructor == null || modulesToLoad.Any(type => type != moduleType && type.GetTypeInfo().IsSubclassOf(moduleType)))
#else
if (constructor == null || modulesToLoad.Any(type => type != moduleType && type.IsSubclassOf(moduleType)))
#endif
{
modulesToLoad.Remove(moduleType);
index--;
continue;
}
var module = (IModule)constructor.InvokeEx(Empty.Array <object>());
modules.Add(module);
}
modules.Sort((module, module1) => module1.Priority.CompareTo(module.Priority));
return(modules);
}
private object[] GetParameters(ConstructorInfo constructor, IList <IIocParameter> parameters)
{
var parameterInfos = constructor.GetParameters();
if (parameterInfos.Length == 0)
{
return(Empty.Array <object>());
}
var result = new object[parameterInfos.Length];
//Find constructor arguments
for (var i = 0; i < parameterInfos.Length; i++)
{
var parameterInfo = parameterInfos[i];
var find = false;
for (var index = 0; index < parameters.Count; index++)
{
var injectionParameter = parameters[index];
if (!CanResolve(injectionParameter, parameterInfo))
{
continue;
}
result[i] = injectionParameter.Value;
find = true;
break;
}
if (find)
{
continue;
}
var resolve = ResolveParameter(parameterInfo.ParameterType, parameterInfo);
result[i] = resolve;
}
return(result);
}
private bool TryResolveSelfBindable(Type service, IIocParameter[] parameters, out object value)
{
BindingRegistration registration;
lock (_selfActivatedRegistrations)
{
if (!_selfActivatedRegistrations.TryGetValue(service, out registration))
{
if (IsSelfBindableType(service))
{
registration = new BindingRegistration(this, service, DependencyLifecycle.TransientInstance, Empty.Array <IIocParameter>());
}
_selfActivatedRegistrations[service] = registration;
}
}
if (registration == null)
{
value = null;
return(false);
}
value = registration.Resolve(parameters);
return(true);
}
private bool TryResolve(Type service, IIocParameter[] parameters, out object value)
{
if (service.IsArray)
{
Type elementType = service.GetElementType();
value = ConvertToArray(service, elementType);
return(true);
}
#if NET4
if (!service.IsGenericType)
#else
if (!service.GetTypeInfo().IsGenericType)
#endif
{ return(TryResolveSelfBindable(service, parameters, out value)); }
Type definition = service.GetGenericTypeDefinition();
ConstructorInfo constructor = null;
var originalType = service.GetGenericArguments()[0];
#if NET4
if (definition.IsInterface)
#else
if (definition.GetTypeInfo().IsInterface)
#endif
{
if (definition == typeof(ICollection <>) || definition == typeof(IEnumerable <>) || definition == typeof(IList <>)
#if !NET4
|| definition == typeof(IReadOnlyCollection <>) || definition == typeof(IReadOnlyList <>)
#endif
)
{
constructor = typeof(List <>).MakeGenericType(originalType).GetConstructor(Empty.Array <Type>());
}
}
else
{
if (typeof(ICollection <>).MakeGenericType(originalType).IsAssignableFrom(service))
{
constructor = service.GetConstructor(Empty.Array <Type>());
}
}
if (constructor == null)
{
return(TryResolveSelfBindable(service, parameters, out value));
}
#if NET4
MethodInfo methodInfo = constructor.DeclaringType?.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public, null, new[] { originalType }, null);
#else
MethodInfo methodInfo = constructor.DeclaringType?.GetRuntimeMethod("Add", new[] { originalType });
#endif
if (methodInfo == null || methodInfo.IsStatic)
{
return(TryResolveSelfBindable(service, parameters, out value));
}
IList <object> objects = GetAll(originalType);
value = constructor.InvokeEx();
var args = new object[1];
foreach (object o in objects)
{
args[0] = o;
methodInfo.InvokeEx(value, args);
}
return(true);
}
public static object InvokeEx([NotNull] this ConstructorInfo constructor)
{
return(constructor.InvokeEx(Empty.Array <object>()));
}
public static object InvokeEx([NotNull] this MethodInfo method, object target)
{
return(method.InvokeEx(target, Empty.Array <object>()));
}
internal static void SetValue <TValue>(this PropertyInfo property, object target, TValue value)
{
property.SetValue(target, value, Empty.Array <object>());
}
