Ejemplo n.º 1
0
        public void Test_CanLoad_AndResolve_BindToProviderType(int nTestThreads)
        {
            StandardDependencyResolver resolver =
                new StandardDependencyResolver();

            List <DependencyRegistration> dependencies =
                new List <DependencyRegistration>();

            dependencies.Add(DependencyRegistration.BindToProvider(typeof(IAsSingletonSampleDependency),
                                                                   typeof(AsSingletonSampleDependencyProvider),
                                                                   DependencyScope.Singleton));

            dependencies.Add(DependencyRegistration.BindToProvider(typeof(IAsThreadSingletonSampleDependency),
                                                                   typeof(AsThreadSingletonSampleDependencyProvider),
                                                                   DependencyScope.Thread));

            dependencies.Add(DependencyRegistration.BindToProvider(typeof(IAsTransientSampleDependency),
                                                                   typeof(AsTransientSampleDependencyProvider),
                                                                   DependencyScope.Transient));

            resolver.Load(dependencies);

            Assert_DependenciesCanBeResolved(resolver);
            Assert_DependenciesCorrectlyResolved(nTestThreads, resolver);
        }
        public IDependencyBindingScopeSetup BindToProvider(Type target,
                                                           Type providerType)
        {
            if (target == null)
            {
                throw new ArgumentNullException(nameof(target));
            }

            if (providerType == null)
            {
                throw new ArgumentNullException(nameof(providerType));
            }

            if (HasBindingFor(target))
            {
                throw new InvalidOperationException($"Target type {target.Name} is already bound.");
            }

            DependencyRegistration reg = DependencyRegistration.BindToProvider(target,
                                                                               asProvider: providerType,
                                                                               scope: DependencyScope.Transient);

            mDependencyRegistrations.Add(reg);
            return(new StandardDependencyBindingScopeSetup(reg));
        }
        public IDependencySetup BindToProvider(Type target,
                                               Type providerType,
                                               DependencyScope scope)
        {
            if (target == null)
            {
                throw new ArgumentNullException(nameof(target));
            }

            if (providerType == null)
            {
                throw new ArgumentNullException(nameof(providerType));
            }

            if (HasBindingFor(target))
            {
                throw new InvalidOperationException($"Target type {target.Name} is already bound.");
            }

            mDependencyRegistrations.Add(DependencyRegistration.BindToProvider(target,
                                                                               asProvider: providerType,
                                                                               scope: scope));

            return(this);
        }
        public IDependencyBindingScopeSetup BindToProvider <T, TImplementation, TProvider> (TImplementation instance)
            where TImplementation : T
            where TProvider : IDependencyProvider <TImplementation>
        {
            if (HasBindingFor <T>())
            {
                throw new InvalidOperationException($"Target type {typeof( T ).Name} is already bound.");
            }

            DependencyRegistration reg = DependencyRegistration.BindToProvider(typeof(T),
                                                                               asProvider: typeof(TProvider),
                                                                               scope: DependencyScope.Transient);

            mDependencyRegistrations.Add(reg);
            return(new StandardDependencyBindingScopeSetup(reg));
        }
        public IDependencySetup BindToProvider <T, TImplementation, TProvider> (TImplementation instance,
                                                                                DependencyScope scope)
            where TImplementation : T
            where TProvider : IDependencyProvider <TImplementation>
        {
            if (HasBindingFor <T>())
            {
                throw new InvalidOperationException($"Target type {typeof( T ).Name} is already bound.");
            }

            mDependencyRegistrations.Add(DependencyRegistration.BindToProvider(typeof(T),
                                                                               asProvider: typeof(TProvider),
                                                                               scope: scope));

            return(this);
        }