public override object GetObject( Type requestedType, DependencyContainer container, DependencyContainerResolveOptions options) { return(_instance); }
private bool CanConstruct( ConstructorInfo ctor, Dictionary <string, object> parameters, DependencyContainerResolveOptions options) { if (parameters == null) { parameters = new Dictionary <string, object>(); } foreach (var parameter in ctor.GetParameters()) { if (string.IsNullOrEmpty(parameter.Name)) { return(false); } var isParameterOverload = parameters.ContainsKey(parameter.Name); if (parameter.ParameterType.IsPrimitive() && !isParameterOverload) { return(false); } if (!isParameterOverload && !CanResolve(new DependencyContainer.TypeRegistration(parameter.ParameterType), null, options)) { return(false); } } return(true); }
/// <summary> /// Attempts to predict whether a given named type can be resolved with the supplied constructor parameters options. /// /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists). /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail. /// /// Note: Resolution may still fail if user defined factory registrations fail to construct objects when called. /// </summary> /// <typeparam name="TResolveType">Type to resolve.</typeparam> /// <param name="name">Name of registration.</param> /// <param name="options">Resolution options.</param> /// <returns>Bool indicating whether the type can be resolved.</returns> public bool CanResolve <TResolveType>( string name = null, DependencyContainerResolveOptions options = null) where TResolveType : class { return(CanResolve(typeof(TResolveType), name, options)); }
private bool CanConstruct( ConstructorInfo ctor, DependencyContainerResolveOptions options) { foreach (var parameter in ctor.GetParameters()) { if (string.IsNullOrEmpty(parameter.Name)) { return(false); } var isParameterOverload = options.ConstructorParameters.ContainsKey(parameter.Name); if (parameter.ParameterType.IsPrimitive() && !isParameterOverload) { return(false); } if (!isParameterOverload && !CanResolve(new DependencyContainer.TypeRegistration(parameter.ParameterType), options.Clone())) { return(false); } } return(true); }
/// <summary> /// Attempts to resolve all public property dependencies on the given object using the given resolve options. /// </summary> /// <param name="input">Object to "build up".</param> /// <param name="resolveOptions">Resolve options to use.</param> public void BuildUp(object input, DependencyContainerResolveOptions resolveOptions = null) { if (resolveOptions == null) { resolveOptions = DependencyContainerResolveOptions.Default; } var properties = input.GetType() .GetProperties() .Where(property => property.GetCacheGetMethod() != null && property.GetCacheSetMethod() != null && !property.PropertyType.IsValueType()); foreach (var property in properties.Where(property => property.GetValue(input, null) == null)) { try { property.SetValue( input, RegisteredTypes.ResolveInternal(new TypeRegistration(property.PropertyType), null, resolveOptions), null); } catch (DependencyContainerResolutionException) { // Catch any resolution errors and ignore them } } }
public override object GetObject( Type requestedType, DependencyContainer container, Dictionary <string, object> parameters, DependencyContainerResolveOptions options) { return(_instance); }
/// <summary> /// Attempts to predict whether a given named type can be resolved with the supplied constructor parameters options. /// /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists). /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail. /// /// Note: Resolution may still fail if user defined factory registrations fail to construct objects when called. /// </summary> /// <typeparam name="TResolveType">Type to resolve.</typeparam> /// <param name="name">Name of registration.</param> /// <param name="parameters">User supplied named parameter overloads.</param> /// <param name="options">Resolution options.</param> /// <returns>Bool indicating whether the type can be resolved.</returns> public bool CanResolve <TResolveType>( string name = null, Dictionary <string, object> parameters = null, DependencyContainerResolveOptions options = null) where TResolveType : class { return(CanResolve(typeof(TResolveType), parameters, name, options)); }
/// <summary> /// Attempts to resolve a type using the supplied options and constructor parameters. /// </summary> /// <param name="resolveType">Type to resolve.</param> /// <param name="parameters">User specified constructor parameters.</param> /// <param name="options">Resolution options.</param> /// <param name="resolvedType">Resolved type or default if resolve fails.</param> /// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns> public bool TryResolve( Type resolveType, Dictionary <string, object> parameters, DependencyContainerResolveOptions options, out object resolvedType) { return(TryResolve(resolveType, null, parameters, options, out resolvedType)); }
internal object ConstructType( Type implementationType, ConstructorInfo constructor, Dictionary <string, object> parameters, DependencyContainerResolveOptions options = null) { var typeToConstruct = implementationType; if (constructor == null) { // Try and get the best constructor that we can construct // if we can't construct any then get the constructor // with the least number of parameters so we can throw a meaningful // resolve exception constructor = GetBestConstructor(typeToConstruct, parameters, options) ?? GetTypeConstructors(typeToConstruct).LastOrDefault(); } if (constructor == null) { throw new DependencyContainerResolutionException(typeToConstruct); } var ctorParams = constructor.GetParameters(); var args = new object[ctorParams.Length]; for (var parameterIndex = 0; parameterIndex < ctorParams.Length; parameterIndex++) { var currentParam = ctorParams[parameterIndex]; try { args[parameterIndex] = parameters.GetValueOrDefault(currentParam.Name, ResolveInternal(new DependencyContainer.TypeRegistration(currentParam.ParameterType), null, options)); } catch (DependencyContainerResolutionException ex) { // If a constructor parameter can't be resolved // it will throw, so wrap it and throw that this can't // be resolved. throw new DependencyContainerResolutionException(typeToConstruct, ex); } catch (Exception ex) { throw new DependencyContainerResolutionException(typeToConstruct, ex); } } try { return(CreateObjectConstructionDelegateWithCache(constructor).Invoke(args)); } catch (Exception ex) { throw new DependencyContainerResolutionException(typeToConstruct, ex); } }
/// <summary> /// Attempts to resolve a type using the given options. /// </summary> /// <param name="resolveType">Type to resolve.</param> /// <param name="options">Resolution options.</param> /// <param name="resolvedType">Resolved type or default if resolve fails.</param> /// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns> public bool TryResolve(Type resolveType, DependencyContainerResolveOptions options, out object resolvedType) { try { resolvedType = Resolve(resolveType, options: options); return(true); } catch (DependencyContainerResolutionException) { resolvedType = null; return(false); } }
public override object GetObject( Type requestedType, DependencyContainer container, DependencyContainerResolveOptions options) { var instance = _instance.Target; if (instance == null) { throw new DependencyContainerWeakReferenceException(_registerType); } return(instance); }
public override object GetObject( Type requestedType, DependencyContainer container, DependencyContainerResolveOptions options) { try { return(_factory.Invoke(container, options.ConstructorParameters)); } catch (Exception ex) { throw new DependencyContainerResolutionException(_registerType, ex); } }
public override object GetObject( Type requestedType, DependencyContainer container, DependencyContainerResolveOptions options) { try { return(container.RegisteredTypes.ConstructType(_registerImplementation, Constructor, options)); } catch (DependencyContainerResolutionException ex) { throw new DependencyContainerResolutionException(_registerType, ex); } }
/// <summary> /// Attempts to resolve a type using the given options. /// </summary> /// <typeparam name="TResolveType">Type to resolve.</typeparam> /// <param name="options">Resolution options.</param> /// <param name="resolvedType">Resolved type or default if resolve fails.</param> /// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns> public bool TryResolve <TResolveType>(DependencyContainerResolveOptions options, out TResolveType resolvedType) where TResolveType : class { try { resolvedType = Resolve <TResolveType>(options: options); return(true); } catch (DependencyContainerResolutionException) { resolvedType = default; return(false); } }
/// <summary> /// Attempts to resolve a type using the supplied name, options and constructor parameters. /// </summary> /// <typeparam name="TResolveType">Type to resolve.</typeparam> /// <param name="name">Name of registration.</param> /// <param name="parameters">User specified constructor parameters.</param> /// <param name="options">Resolution options.</param> /// <param name="resolvedType">Resolved type or default if resolve fails.</param> /// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns> public bool TryResolve <TResolveType>(string name, Dictionary <string, object> parameters, DependencyContainerResolveOptions options, out TResolveType resolvedType) where TResolveType : class { try { resolvedType = Resolve <TResolveType>(name, parameters, options); return(true); } catch (DependencyContainerResolutionException) { resolvedType = default; return(false); } }
/// <summary> /// Attempts to resolve a type using the supplied name, options and constructor parameters. /// </summary> /// <param name="resolveType">Type to resolve.</param> /// <param name="name">Name of registration.</param> /// <param name="parameters">User specified constructor parameters.</param> /// <param name="options">Resolution options.</param> /// <param name="resolvedType">Resolved type or default if resolve fails.</param> /// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns> public bool TryResolve( Type resolveType, string name, Dictionary <string, object> parameters, DependencyContainerResolveOptions options, out object resolvedType) { try { resolvedType = Resolve(resolveType, name, parameters, options); return(true); } catch (DependencyContainerResolutionException) { resolvedType = null; return(false); } }
public override object GetObject( Type requestedType, DependencyContainer container, DependencyContainerResolveOptions options) { if (!(_factory.Target is Func <DependencyContainer, Dictionary <string, object>, object> factory)) { throw new DependencyContainerWeakReferenceException(_registerType); } try { return(factory.Invoke(container, options.ConstructorParameters)); } catch (Exception ex) { throw new DependencyContainerResolutionException(_registerType, ex); } }
public override object GetObject( Type requestedType, DependencyContainer container, DependencyContainerResolveOptions options) { if (options.ConstructorParameters.Count != 0) { throw new ArgumentException("Cannot specify parameters for singleton types"); } lock (_singletonLock) { if (_current == null) { _current = container.RegisteredTypes.ConstructType(_registerImplementation, Constructor, options); } } return(_current); }
/// <summary> /// Create the type. /// </summary> /// <param name="requestedType">Type user requested to be resolved.</param> /// <param name="container">Container that requested the creation.</param> /// <param name="parameters">Any user parameters passed.</param> /// <param name="options">The options.</param> /// <returns> Instance of type. </returns> public abstract object GetObject( Type requestedType, DependencyContainer container, Dictionary <string, object> parameters, DependencyContainerResolveOptions options);
/// <summary> /// Create the type. /// </summary> /// <param name="requestedType">Type user requested to be resolved.</param> /// <param name="container">Container that requested the creation.</param> /// <param name="options">The options.</param> /// <returns> Instance of type. </returns> public abstract object GetObject( Type requestedType, DependencyContainer container, DependencyContainerResolveOptions options);
/// <summary> /// Attempts to predict whether a given type can be resolved with the supplied constructor parameters options. /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists). /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail. /// Note: Resolution may still fail if user defined factory registrations fail to construct objects when called. /// </summary> /// <param name="resolveType">Type to resolve.</param> /// <param name="parameters">User supplied named parameter overloads.</param> /// <param name="name">The name.</param> /// <param name="options">Resolution options.</param> /// <returns> /// Bool indicating whether the type can be resolved. /// </returns> public bool CanResolve( Type resolveType, Dictionary <string, object> parameters = null, string name = null, DependencyContainerResolveOptions options = null) => RegisteredTypes.CanResolve(new TypeRegistration(resolveType, name), parameters, options);
/// <summary> /// Attempts to resolve a named type using specified options and the supplied constructor parameters. /// /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists). /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail. /// </summary> /// <param name="resolveType">Type to resolve.</param> /// <param name="name">Name of registration.</param> /// <param name="parameters">User specified constructor parameters.</param> /// <param name="options">Resolution options.</param> /// <returns>Instance of type.</returns> /// <exception cref="DependencyContainerResolutionException">Unable to resolve the type.</exception> public object Resolve( Type resolveType, string name = null, Dictionary <string, object> parameters = null, DependencyContainerResolveOptions options = null) => RegisteredTypes.ResolveInternal(new TypeRegistration(resolveType, name), parameters, options ?? DependencyContainerResolveOptions.Default);
internal object ResolveInternal( DependencyContainer.TypeRegistration registration, Dictionary <string, object> parameters, DependencyContainerResolveOptions options = null) { if (parameters == null) { parameters = new Dictionary <string, object>(); } if (options == null) { options = DependencyContainerResolveOptions.Default; } // Attempt container resolution if (TryGetValue(registration, out var factory)) { try { return(factory.GetObject(registration.Type, _dependencyContainer, parameters, options)); } catch (DependencyContainerResolutionException) { throw; } catch (Exception ex) { throw new DependencyContainerResolutionException(registration.Type, ex); } } // Attempt to get a factory from parent if we can var bubbledObjectFactory = GetParentObjectFactory(registration); if (bubbledObjectFactory != null) { try { return(bubbledObjectFactory.GetObject(registration.Type, _dependencyContainer, parameters, options)); } catch (DependencyContainerResolutionException) { throw; } catch (Exception ex) { throw new DependencyContainerResolutionException(registration.Type, ex); } } // Fail if requesting named resolution and settings set to fail if unresolved if (!string.IsNullOrEmpty(registration.Name) && options.NamedResolutionFailureAction == DependencyContainerNamedResolutionFailureActions.Fail) { throw new DependencyContainerResolutionException(registration.Type); } // Attempted unnamed fallback container resolution if relevant and requested if (!string.IsNullOrEmpty(registration.Name) && options.NamedResolutionFailureAction == DependencyContainerNamedResolutionFailureActions.AttemptUnnamedResolution) { if (TryGetValue(new DependencyContainer.TypeRegistration(registration.Type, string.Empty), out factory)) { try { return(factory.GetObject(registration.Type, _dependencyContainer, parameters, options)); } catch (DependencyContainerResolutionException) { throw; } catch (Exception ex) { throw new DependencyContainerResolutionException(registration.Type, ex); } } } // Attempt unregistered construction if possible and requested var isValid = (options.UnregisteredResolutionAction == DependencyContainerUnregisteredResolutionActions.AttemptResolve) || (registration.Type.IsGenericType() && options.UnregisteredResolutionAction == DependencyContainerUnregisteredResolutionActions.GenericsOnly); return(isValid && !registration.Type.IsAbstract() && !registration.Type.IsInterface() ? ConstructType(registration.Type, null, parameters, options) : throw new DependencyContainerResolutionException(registration.Type)); }
/// <summary> /// Attempts to predict whether a given type can be resolved with the supplied constructor parameters options. /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists). /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail. /// Note: Resolution may still fail if user defined factory registrations fail to construct objects when called. /// </summary> /// <param name="resolveType">Type to resolve.</param> /// <param name="name">The name.</param> /// <param name="options">Resolution options.</param> /// <returns> /// Bool indicating whether the type can be resolved. /// </returns> public bool CanResolve( Type resolveType, string name = null, DependencyContainerResolveOptions options = null) => RegisteredTypes.CanResolve(new TypeRegistration(resolveType, name), options);
private ConstructorInfo GetBestConstructor( Type type, Dictionary <string, object> parameters, DependencyContainerResolveOptions options) => type.IsValueType() ? null : GetTypeConstructors(type).FirstOrDefault(ctor => CanConstruct(ctor, parameters, options));
internal bool CanResolve( DependencyContainer.TypeRegistration registration, Dictionary <string, object> parameters = null, DependencyContainerResolveOptions options = null) { if (parameters == null) { parameters = new Dictionary <string, object>(); } if (options == null) { options = DependencyContainerResolveOptions.Default; } var checkType = registration.Type; var name = registration.Name; if (TryGetValue(new DependencyContainer.TypeRegistration(checkType, name), out var factory)) { if (factory.AssumeConstruction) { return(true); } if (factory.Constructor == null) { return(GetBestConstructor(factory.CreatesType, parameters, options) != null); } return(CanConstruct(factory.Constructor, parameters, options)); } // Fail if requesting named resolution and settings set to fail if unresolved // Or bubble up if we have a parent if (!string.IsNullOrEmpty(name) && options.NamedResolutionFailureAction == DependencyContainerNamedResolutionFailureActions.Fail) { return(_dependencyContainer.Parent?.RegisteredTypes.CanResolve(registration, parameters, options) ?? false); } // Attempted unnamed fallback container resolution if relevant and requested if (!string.IsNullOrEmpty(name) && options.NamedResolutionFailureAction == DependencyContainerNamedResolutionFailureActions.AttemptUnnamedResolution) { if (TryGetValue(new DependencyContainer.TypeRegistration(checkType), out factory)) { if (factory.AssumeConstruction) { return(true); } return(GetBestConstructor(factory.CreatesType, parameters, options) != null); } } // Check if type is an automatic lazy factory request or an IEnumerable<ResolveType> if (IsAutomaticLazyFactoryRequest(checkType) || registration.Type.IsIEnumerable()) { return(true); } // Attempt unregistered construction if possible and requested // If we cant', bubble if we have a parent if ((options.UnregisteredResolutionAction == DependencyContainerUnregisteredResolutionActions.AttemptResolve) || (checkType.IsGenericType() && options.UnregisteredResolutionAction == DependencyContainerUnregisteredResolutionActions.GenericsOnly)) { return((GetBestConstructor(checkType, parameters, options) != null) || (_dependencyContainer.Parent?.RegisteredTypes.CanResolve(registration, parameters, options) ?? false)); } // Bubble resolution up the container tree if we have a parent return(_dependencyContainer.Parent != null && _dependencyContainer.Parent.RegisteredTypes.CanResolve(registration, parameters, options)); }
private ConstructorInfo GetBestConstructor( Type type, DependencyContainerResolveOptions options) => type.IsValueType() ? null : GetTypeConstructors(type).FirstOrDefault(ctor => CanConstruct(ctor, options));