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