public void ClosedTypesRegistration_ShouldWork()
        {
            IResolver resolver = Building(builder => { builder.RegisterServices(r => r.RegisterAssemblyAsClosedTypesOf(Assembly.Load(new AssemblyName("Autofac.Extras.IocManager.Tests")), typeof(IMyGenericInterface <>))); });

            resolver.IsRegistered <MyBaseClass>().Should().Be(true);
            resolver.IsRegistered <MyGeneric <SomeClass> >().Should().Be(true);
            resolver.IsRegistered <IMyGenericInterface <SomeClass> >().Should().Be(true);
        }
예제 #2
0
        public void Module_Registration_Should_Work_WithExtension()
        {
            IResolver resolver = Building(builder => { builder.UseEventStore(); });

            bool moduleBasedEventStore = resolver.IsRegistered <IModuleBasedEventStore>();

            moduleBasedEventStore.ShouldNotBeNull();
        }
예제 #3
0
        public void Module_Registration_Should_Work()
        {
            IResolver resolver = Building(builder => { builder.RegisterModule <FakeEventStoreModule>(); });

            bool moduleBasedEventStore = resolver.IsRegistered <IModuleBasedEventStore>();

            moduleBasedEventStore.ShouldNotBeNull();
        }
예제 #4
0
        public void FluentBootstrapper_Should_Work()
        {
            IResolver resolver = Building(builder =>
            {
                builder.UseNLog()
                .UseEventStore()
                .UseRabbitMQ()
                .RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.Load(new AssemblyName("Autofac.Extras.IocManager.Tests"))));
            });

            resolver.IsRegistered <IEventStore>().ShouldBe(true);
            resolver.IsRegistered <ILogger>().ShouldBe(true);
            resolver.IsRegistered <IBus>().ShouldBe(true);

            LocalIocManager.IsRegistered <IEventStore>().ShouldBe(true);
            LocalIocManager.IsRegistered <ILogger>().ShouldBe(true);
            LocalIocManager.IsRegistered <IBus>().ShouldBe(true);
        }
예제 #5
0
        /// <summary>
        ///     Resolves if exists.
        /// </summary>
        /// <param name="resolver">The resolver.</param>
        /// <param name="type">The type.</param>
        /// <param name="instance">The instance.</param>
        /// <returns></returns>
        public static bool ResolveIfExists([NotNull] this IResolver resolver, [NotNull] Type type, [CanBeNull] out object instance)
        {
            instance = null;
            if (resolver.IsRegistered(type))
            {
                instance = resolver.Resolve(type);
                return(true);
            }

            return(false);
        }
예제 #6
0
        /// <summary>
        ///     Resolves if exists.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="resolver">The resolver.</param>
        /// <param name="instance">The instance.</param>
        /// <returns></returns>
        public static bool ResolveIfExists <T>([NotNull] this IResolver resolver, [CanBeNull] out T instance) where T : class
        {
            instance = null;
            if (resolver.IsRegistered <T>())
            {
                instance = resolver.Resolve <T>();
                return(true);
            }

            return(false);
        }
        /// <summary>
        /// Creates a <see cref="T:Newtonsoft.Json.Serialization.JsonObjectContract" /> for the given type.
        /// </summary>
        /// <param name="objectType">Type of the object.</param>
        /// <returns>A <see cref="T:Newtonsoft.Json.Serialization.JsonObjectContract" /> for the given type.</returns>
        protected override JsonObjectContract CreateObjectContract(Type objectType)
        {
            var contract = base.CreateObjectContract(objectType);

            // use Resolver to create types that have been registered with it
            if (_container.IsRegistered(objectType))
            {
                contract.DefaultCreator = () => _container.Resolve(objectType);
            }

            return(contract);
        }
예제 #8
0
 public bool IsRegistered(Type type)
 {
     return(_iocResolver.IsRegistered(type));
 }