private static void Register(Type interfaceType, Lifestyle lifestyle, List<Type> types)
        {
            if (!DuplicateImplementationsExists(types))
            {
                foreach (var type in types)
                {
                    var typeInterface = type.GetInterfaces().First(x => x.Name == interfaceType.Name);

                    var registerOptions = TinyIoCContainer.Current.Register(typeInterface, type);
                    if (lifestyle == Lifestyle.PerRequest)
                        registerOptions.AsMultiInstance();
                    else
                    {
                        registerOptions.AsSingleton();
                    }
                }
            }
            else
            {
                var multiRegisterOptions = TinyIoCContainer.Current.RegisterMultiple(interfaceType, types);
                if (lifestyle == Lifestyle.PerRequest)
                    multiRegisterOptions.AsMultiInstance();
                else
                {
                    multiRegisterOptions.AsSingleton();
                }
            }
        }

		/// <summary>
		/// 	Configures component with default service type (first not-IConrainerBound interface) with no name and default Priority/Lifestyle
		/// </summary>
		public ContainerComponentAttribute(Type serviceType = null, Lifestyle lifestyle = Lifestyle.Default, string name = "",
		                                   int priority = -1) {
			Priority = priority; //default component level for manifest (assembly level will be used)
			Lifestyle = lifestyle;
			Name = name;
			ServiceType = serviceType; //will be resolved automatically
		}

 public static void Initialize(Container container, Lifestyle lifestyle)
 {
     container.Register<IProdutoRepository, ProdutoRepository>(lifestyle);
     container.Register<ICompraRepository, CompraRepository>(lifestyle);
     container.Register<ICompraItemRepository, CompraItemRepository>(lifestyle);
     container.Register<IFornecedorRepository, FornecedorRepository>(lifestyle);
 }

 public frmSelectLifestyleAdvanced(Lifestyle objLifestyle, Character objCharacter)
 {
     InitializeComponent();
     LanguageManager.Instance.Load(GlobalOptions.Instance.Language, this);
     _objCharacter = objCharacter;
     _objLifestyle = objLifestyle;
     MoveControls();
 }

        public static Container RegisterItems(Container container, Lifestyle lifeStyle)
        {
            RegisterItemsDataAccess(container, lifeStyle);
            RegisterItemsDataBusiness(container, lifeStyle);


            return container;
        }

 public frmSelectAdvancedLifestyle(Lifestyle objLifestyle, Character objCharacter)
 {
     InitializeComponent();
     LanguageManager.Instance.Load(this);
     _objCharacter = objCharacter;
     _objLifestyle = objLifestyle;
     MoveControls();
 }

 public static void Register(Container container, Lifestyle lifestyle)
 {
     //container.RegisterAll<IConexao<T>>(Conexao<T>)>(lifestyle);
     container.Register<ICompraDal, CompraDal>(lifestyle);
     container.Register<ICompraItemDal, CompraItemDal>(lifestyle);
     container.Register<IClienteDal, ClienteDal>(lifestyle);
     container.Register<IFornecedorDal, FornecedorDal>(lifestyle);
 }

 internal TornLifestyleDiagnosticResult(Type serviceType, string description, Lifestyle lifestyle,
     Type implementationType, InstanceProducer[] affectedRegistrations)
     : base(serviceType, description, DiagnosticType.TornLifestyle, DiagnosticSeverity.Warning,
         CreateDebugValue(implementationType, lifestyle, affectedRegistrations))
 {
     this.Lifestyle = lifestyle;
     this.ImplementationType = implementationType;
     this.AffectedRegistrations = new ReadOnlyCollection<InstanceProducer>(affectedRegistrations.ToList());
 }

        internal ExpressionBuildingEventArgs(Type registeredServiceType, Type knownImplementationType, 
            Expression expression, Lifestyle lifestyle)
        {
            this.RegisteredServiceType = registeredServiceType;
            this.KnownImplementationType = knownImplementationType;
            this.Lifestyle = lifestyle;

            this.expression = expression;
        }

        public static void RegisterApp(this Container container, Lifestyle lifestyle)
        {
            container.Register<CursoAngularJsContext>(lifestyle);
            container.BatchRegister<ClienteRepository>();
            container.BatchRegister<ClienteApplicationService>();

            ServiceLocator.SetLocatorProvider(
                () => new Adapters.SimpleInjectorServiceLocatorAdapter(container));
        }

        internal ExpressionRegistration(Expression expression, Type implementationType, Lifestyle lifestyle, 
            Container container)
            : base(lifestyle, container)
        {
            Requires.IsNotNull(expression, nameof(expression));
            Requires.IsNotNull(implementationType, nameof(implementationType));

            this.expression = expression;
            this.implementationType = implementationType;
        }

 public static void RegisterModelDependencies(this Container container, Lifestyle lifestyle)
 {
     container.Register<AdvertiserAccountService, AdvertiserAccountService>(lifestyle);
     container.Register<CryptographyService, CryptographyService>(lifestyle);
     container.Register<AuthenticationService, AuthenticationService>(lifestyle);
     container.Register<LocationService, LocationService>(lifestyle);
     container.Register<ServiceSolicitationService, ServiceSolicitationService>(lifestyle);
     container.Register<ContractModelService,ContractModelService>(lifestyle);
     container.Register<AdvertisementService, AdvertisementService>(lifestyle);
 }

        public DefaultComponentProfile( String key, Type service, Type implementation,
			Lifestyle lifestyle, Activation activation, IConfiguration configuration )
        {
            m_key = key;
            m_service = service;
            m_implementation = implementation;
            m_lifestyle = lifestyle;
            m_activation = activation;
            m_configuration = configuration;
        }

 public DecoratorExpressionInterceptorData(Container container, Type serviceType, Type decoratorType,
     Predicate<DecoratorPredicateContext> predicate, Lifestyle lifestyle,
     Func<DecoratorPredicateContext, Type> decoratorTypeFactory = null)
 {
     this.Container = container;
     this.ServiceType = serviceType;
     this.DecoratorType = decoratorType;
     this.DecoratorTypeFactory = this.WrapInNullProtector(decoratorTypeFactory);
     this.Predicate = predicate;
     this.Lifestyle = lifestyle;
 }

        public static void Register(Container container, Lifestyle lifeStyleDbContext)
        {
            //Containers.ApplicationServiceContainer.RegisterApplicationService(container);
            container.RegisterApplicationServices();
            container.RegisterDomainServices();
            container.RegisterRepositories();

            container.RegisterDbContexts(lifeStyleDbContext);

            ServiceLocatorConfig(container);
        }

        private static void RegisterItemsDataAccess(Container container, Lifestyle lifeStyle)
        {
            container.Register<IPersonRepository, PersonRepository>(lifeStyle);
            //container.Register<typeof(AdventureContext), AdventureContext > (lifeStyle);
            container.Register<DbContext, AdventureContext>(lifeStyle);
            container.Register<IUnitOfWork, UnitOfWork>(lifeStyle);

            //builder.RegisterType(typeof(SampleArchContext)).As(typeof(DbContext)).InstancePerLifetimeScope();
            //builder.RegisterType(typeof(UnitOfWork)).As(typeof(IUnitOfWork)).InstancePerRequest();

        }

 internal AmbiguousLifestylesDiagnosticResult(Type serviceType, string description, 
     Lifestyle[] lifestyles, Type implementationType, InstanceProducer diagnosedProducer, 
     InstanceProducer[] conflictingProducers)
     : base(serviceType, description, DiagnosticType.AmbiguousLifestyles, DiagnosticSeverity.Warning,
         CreateDebugValue(implementationType, lifestyles, conflictingProducers))
 {
     this.Lifestyles = new ReadOnlyCollection<Lifestyle>(lifestyles.ToList());
     this.ImplementationType = implementationType;
     this.DiagnosedRegistration = diagnosedProducer;
     this.ConflictingRegistrations = new ReadOnlyCollection<InstanceProducer>(conflictingProducers.ToList());
 }

        private static void RegisterServices(Container container, Assembly assembly, Lifestyle lifestyle)
        {
            var registrations = assembly.GetExportedTypes()
                                 .Where(t => t.GetInterfaces().Any())
                                 .Select(t => new { Service = t.GetInterfaces().Single(), Implementation = t });

            foreach (var reg in registrations)
            {
                container.Register(reg.Service, reg.Implementation, lifestyle);
            }
        }

        public static void Bootstrap(Container container, Lifestyle lifestyle)
        {
            container.RegisterApplicationServices();
            container.RegisterDomainServices();
            container.RegisterRepositories();
            container.RegisterDbContexts(lifestyle);
            container.RegisterUnitsOfWork();

            ServiceLocator.SetLocatorProvider(
                () => new Adapters.SimpleInjectorServiceLocatorAdapter(container));
        }

 public HybridRegistration(Type serviceType, Type implementationType, Func<bool> test,
     Registration trueRegistration, Registration falseRegistration,
     Lifestyle lifestyle, Container container)
     : base(lifestyle, container)
 {
     this.serviceType = serviceType;
     this.implementationType = implementationType;
     this.test = test;
     this.trueRegistration = trueRegistration;
     this.falseRegistration = falseRegistration;
 }