static Exception TryResolveWithType(this IObjectResolver resolver, Type contractType, ParameterSet parameters, out object instance) { Requires.NotNull(resolver, "resolver"); Requires.NotNull(contractType, "contractType"); ObjectBuilder builder; var state = resolver.Kernel.TryGet(contractType, out builder); switch (state) { case ObjectBuilderState.Normal: instance = resolver.Resolve(builder, parameters); return(null); case ObjectBuilderState.Invalid: instance = null; return(new ObjectBuilderNotFoundException(GetObjectBuilderNotFoundErrorMessage(contractType))); case ObjectBuilderState.Unregistered: builder = resolver.Kernel.AutoObjectRegistrar.GetObjectBuilder(contractType); if (builder == null) { instance = null; return(new ObjectBuilderNotFoundException(GetObjectBuilderNotFoundErrorMessage(contractType))); } instance = resolver.Resolve(builder, parameters); return(null); default: throw new ImpossibleException(); } }
public T Resolve <T>() { if (isDisposed) { throw new ObjectDisposedException(this.GetType().Name); } var lifestyle = resolver.Lifestyle(typeof(T)); switch (lifestyle) { case MicroResolver.Lifestyle.Transient: case MicroResolver.Lifestyle.Singleton: return(resolver.Resolve <T>()); case MicroResolver.Lifestyle.Scoped: bool isFirstCreated; var v = (T)provider.GetValueFromScoped(typeof(T), out isFirstCreated); if (isFirstCreated && v is IDisposable) { lock (disposeTarget) { disposeTarget.Add((IDisposable)v); } } return(v); default: throw new InvalidOperationException("Invalid Lifestyle:" + lifestyle); } }
public Task <object> GetValueAsync() { var injectAttribute = _parameterInfo.GetCustomAttribute <InjectAttribute>(); if (!injectAttribute.HasName) { return(Task.FromResult(_objectResolver.Resolve(Type))); } return(Task.FromResult(_objectResolver.Resolve(Type, injectAttribute.Name))); }
public IEnumerable <T> ParseInput <T>(string input) { var xml = XElement.Parse(input); // some more code here var parser = _resolver.Resolve <IParser <T> >(); return(parser.Parse(xml)); }
public static T Resolve <T>(this IObjectResolver resolver, IObjectObserver <T> observer) { var builder = observer.ObjectBuilder; if (builder == null) { throw new ObsoleteObjectBuilderException(GetObsoleteObjectBuilderErrorMessage(observer.ContractType)); } return(resolver.Resolve(builder, null)); }
public object GetLogger(IObjectResolver objectResolver, Type declaringType) { // method is used to resolve logger instances azure function implementations with [inject] attribute return(GetLogger(declaringType, delegate { var factory = objectResolver.Resolve <ILoggerFactory>(); var loggerName = GetLoggerName(declaringType); return factory.CreateLogger(loggerName); })); }
void InjectMethods(object obj, IObjectResolver resolver, IReadOnlyList <IInjectParameter> parameters) { if (injectTypeInfo.InjectMethods == null) { return; } foreach (var method in injectTypeInfo.InjectMethods) { var parameterInfos = method.ParameterInfos; var parameterValues = CappedArrayPool <object> .Shared8Limit.Rent(parameterInfos.Length); try { for (var i = 0; i < parameterInfos.Length; i++) { var set = false; var parameterInfo = parameterInfos[i]; if (parameters != null) { foreach (var x in parameters) { if (x.Match(parameterInfo)) { parameterValues[i] = x.Value; set = true; break; } } } if (set) { continue; } var parameterType = parameterInfo.ParameterType; try { parameterValues[i] = resolver.Resolve(parameterType); } catch (VContainerException ex) { throw new VContainerException(parameterType, $"Failed to resolve {injectTypeInfo.Type.FullName} : {ex.Message}"); } } method.Invoke(obj, parameterValues); } finally { CappedArrayPool <object> .Shared8Limit.Return(parameterValues); } } }
public Task <object> GetValueAsync() { var injectAttribute = _parameterInfo.GetCustomAttribute <InjectAttribute>(); if (injectAttribute.HasName) { return(Task.FromResult(_objectResolver.Resolve(Type, injectAttribute.Name))); } if (Type != typeof(ILogger)) { return(Task.FromResult(_objectResolver.Resolve(Type))); } //logging does not consider naming //logging for Azure Functions cannot contain any <T> as the function's class is static and cannot be used to //define a concrete type for generic usage. var loggerResolver = _objectResolver.Resolve <LoggerResolver>(); return(Task.FromResult(loggerResolver.GetLogger(_objectResolver, _parameterInfo.Member.DeclaringType))); }
void InjectFields(object obj, IObjectResolver resolver) { if (injectTypeInfo.InjectFields == null) { return; } foreach (var x in injectTypeInfo.InjectFields) { var fieldValue = resolver.Resolve(x.FieldType); x.SetValue(obj, fieldValue); } }
void InjectProperties(object obj, IObjectResolver resolver) { if (injectTypeInfo.InjectProperties == null) { return; } foreach (var x in injectTypeInfo.InjectProperties) { var propValue = resolver.Resolve(x.PropertyType); x.SetValue(obj, propValue); } }
static Exception TryResolveWithObjectRegistration <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, ParameterSet parameters, out T instance) { try { instance = resolver.Resolve(registration.ObjectBuilder, parameters); return(null); } catch (Exception ex) { instance = default(T); return(ex); } }
public static Exception TryResolve <T>(IObjectResolver resolver, ObjectBuilder <T> builder, ParameterSet parameters, out T instance) { try { instance = resolver.Resolve(builder, parameters); } catch (Exception ex) { instance = default(T); return(ex); } return(null); }
public static Exception TryResolve(IObjectResolver resolver, ObjectBuilder builder, ParameterSet parameters, out object instance) { try { instance = resolver.Resolve(builder, parameters); } catch (Exception ex) { instance = null; return(ex); } return(null); }
public object CreateInstance(IObjectResolver resolver, IReadOnlyList <IInjectParameter> parameters) { var parameterInfos = injectTypeInfo.InjectConstructor.ParameterInfos; var parameterValues = CappedArrayPool <object> .Shared8Limit.Rent(parameterInfos.Length); try { for (var i = 0; i < parameterInfos.Length; i++) { var set = false; var parameterInfo = parameterInfos[i]; if (parameters != null) { foreach (var x in parameters) { if (!x.Match(parameterInfo)) { continue; } parameterValues[i] = x.Value; set = true; break; } } if (set) { continue; } try { parameterValues[i] = resolver.Resolve(parameterInfo.ParameterType); } catch (VContainerException ex) { throw new VContainerException(injectTypeInfo.Type, $"Failed to resolve {injectTypeInfo.Type.FullName} : {ex.Message}"); } } var instance = injectTypeInfo.InjectConstructor.Factory(parameterValues); Inject(instance, resolver, parameters); return(instance); } finally { CappedArrayPool <object> .Shared8Limit.Return(parameterValues); } }
public static T[] ResolveAll <T>(this IObjectResolver resolver, IObjectCollectionObserver <T> observer) { var builders = observer.ObjectBuilders; if (builders == null) { throw new ObsoleteObjectBuilderException(GetObsoleteObjectBuilderErrorMessage(observer.ContractType)); } var result = new T[builders.Length]; for (int i = 0; i < builders.Length; i++) { result[i] = resolver.Resolve(builders[i], null); } return(result); }
protected override object GetValueFromScoped(Type type, out bool isFirstCreated) { var v = objects.GetOrAdd(type, createValue); var value = v.Value; if (value == null) { v.Value = value = resolver.Resolve(type); isFirstCreated = true; } else { isFirstCreated = false; } return(value); }
World GetWorld(IObjectResolver resolver) { if (worldName is null && World.DefaultGameObjectInjectionWorld != null) { return(World.DefaultGameObjectInjectionWorld); } var worlds = resolver.Resolve <IEnumerable <World> >(); foreach (var world in worlds) { if (world.Name == worldName) { return(world); } } throw new VContainerException(ImplementationType, $"World `{worldName}` is not registered"); }
public static object ResolveOrParameter( this IObjectResolver resolver, Type parameterType, string parameterName, IReadOnlyList <IInjectParameter> parameters) { if (parameters != null) { foreach (var parameter in parameters) { if (parameter.Match(parameterType, parameterName)) { return(parameter.Value); } } } return(resolver.Resolve(parameterType)); }
/// <summary> /// Retrieve all service associated with the <typeparamref name="TContract"/> and use those components /// to build a object instances. /// </summary> /// <typeparam name="TContract">The type of the contract.</typeparam> /// <param name="resolver">The resolver.</param> /// <returns></returns> public static IList <TContract> ResolveAll <TContract>(this IObjectResolver resolver) { Requires.NotNull(resolver, "resolver"); IEnumerable <ObjectBuilder <TContract> > builders; if (!resolver.Kernel.TryGet(typeof(TContract), out builders)) { throw new ObjectBuilderNotFoundException(GetObjectBuilderNotFoundErrorMessage(typeof(TContract))); } var instances = new List <TContract>(); foreach (var builder in builders) { var instance = resolver.Resolve(builder, null); instances.Add(instance); } return(instances); }
public static object ResolveOrParameter( this IObjectResolver resolver, Type parameterType, string parameterName, IReadOnlyList <IInjectParameter> parameters) { if (parameters != null) { // ReSharper disable once ForCanBeConvertedToForeach for (var i = 0; i < parameters.Count; i++) { var parameter = parameters[i]; if (parameter.Match(parameterType, parameterName)) { return(parameter.Value); } } } return(resolver.Resolve(parameterType)); }
public object SpawnInstance(IObjectResolver resolver) { var genericType = typeof(List <>).MakeGenericType(elementType); var parameterValues = CappedArrayPool <object> .Shared8Limit.Rent(1); parameterValues[0] = registrations.Count; var list = (IList)Activator.CreateInstance(genericType, parameterValues); try { foreach (var registration in registrations) { list.Add(resolver.Resolve(registration)); } } finally { CappedArrayPool <object> .Shared8Limit.Return(parameterValues); } return(list); }
public static object Resolve(this IObjectResolver resolver, IObjectRegistration registration, IList <NamedParameter> overridenParameters) { return(resolver.Resolve(registration.ObjectBuilder, new NamedParameterSet(overridenParameters))); }
public static T Resolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, params NamedParameter[] overridenParameters) { return(resolver.Resolve(registration.ObjectBuilder, new NamedParameterSet(overridenParameters))); }
public void Resolve(IObjectResolver aHandler) { aHandler.Resolve(this); }
ThreadLocal <object> CreateValue(Type key) { return(new ThreadLocal <object>(() => resolver.Resolve(key))); }
Lazy <object> CreateValue(Type key) { return(new Lazy <object>(() => resolver.Resolve(key))); }
public object GetService(Type serviceType) { return(resolver.Resolve(serviceType)); }
public Task <object> GetValueAsync() { return(Task.FromResult(_objectResolver.Resolve(Type))); }
public void Dispatch() { PlayerLoopHelper.Initialize(); EntryPointExceptionHandler exceptionHandler = null; try { exceptionHandler = container.Resolve <EntryPointExceptionHandler>(); } catch (VContainerException ex) when(ex.InvalidType == typeof(EntryPointExceptionHandler)) { } var initializables = container.Resolve <IReadOnlyList <IInitializable> >(); if (initializables.Count > 0) { var loopItem = new InitializationLoopItem(initializables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.Initialization, loopItem); } var postInitializables = container.Resolve <IReadOnlyList <IPostInitializable> >(); if (postInitializables.Count > 0) { var loopItem = new PostInitializationLoopItem(postInitializables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostInitialization, loopItem); } var startables = container.Resolve <IReadOnlyList <IStartable> >(); if (startables.Count > 0) { var loopItem = new StartableLoopItem(startables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.Startup, loopItem); } var postStartables = container.Resolve <IReadOnlyList <IPostStartable> >(); if (postStartables.Count > 0) { var loopItem = new PostStartableLoopItem(postStartables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostStartup, loopItem); } var fixedTickables = container.Resolve <IReadOnlyList <IFixedTickable> >(); if (fixedTickables.Count > 0) { var loopItem = new FixedTickableLoopItem(fixedTickables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.FixedUpdate, loopItem); } var postFixedTickables = container.Resolve <IReadOnlyList <IPostFixedTickable> >(); if (postFixedTickables.Count > 0) { var loopItem = new PostFixedTickableLoopItem(postFixedTickables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostFixedUpdate, loopItem); } var tickables = container.Resolve <IReadOnlyList <ITickable> >(); if (tickables.Count > 0) { var loopItem = new TickableLoopItem(tickables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.Update, loopItem); } var postTickables = container.Resolve <IReadOnlyList <IPostTickable> >(); if (postTickables.Count > 0) { var loopItem = new PostTickableLoopItem(postTickables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostUpdate, loopItem); } var lateTickables = container.Resolve <IReadOnlyList <ILateTickable> >(); if (lateTickables.Count > 0) { var loopItem = new LateTickableLoopItem(lateTickables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.LateUpdate, loopItem); } var postLateTickables = container.Resolve <IReadOnlyList <IPostLateTickable> >(); if (postLateTickables.Count > 0) { var loopItem = new PostLateTickableLoopItem(postLateTickables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostLateUpdate, loopItem); } #if VCONTAINER_UNITASK_INTEGRATION var asyncStartables = container.Resolve <IReadOnlyList <IAsyncStartable> >(); if (asyncStartables.Count > 0) { var loopItem = new AsyncStartableLoopItem(asyncStartables, exceptionHandler); disposable.Add(loopItem); PlayerLoopHelper.Dispatch(PlayerLoopTiming.Startup, loopItem); } #endif #if VCONTAINER_ECS_INTEGRATION container.Resolve <IEnumerable <ComponentSystemBase> >(); var worldHelpers = container.Resolve <IEnumerable <WorldConfigurationHelper> >(); foreach (var x in worldHelpers) { x.SortSystems(); } #endif }
public static T Resolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, IEnumerable <NamedParameter> overridenParameters) { return(resolver.Resolve(registration.ObjectBuilder, new NamedParameterSet(overridenParameters.ToList()))); }
public static T GetInstance <T>() { return(resolver.Resolve <T>()); }
public override void InitializeForView(IObjectResolver resolver) { Recipe = resolver.Resolve<IRecipeProvider>().Get(RecipeId); }