public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            // Configure Web API to use only bearer token authentication.
            config.SuppressDefaultHostAuthentication();
            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            //Unity
            var container = new UnityContainer();
            container.RegisterType<IUnitOfWork, UnitOfWork>(new HierarchicalLifetimeManager());
            container.RegisterType<IGenericRepository<Farmacia>, GenericRepository<Farmacia>>(new HierarchicalLifetimeManager());
            config.DependencyResolver = new UnityResolver(container);

            //Formatters
            config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
            //GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
            //config.Formatters.Insert(0, new System.Net.Http.Formatting.JsonMediaTypeFormatter());

            // Web API routes
            config.MapHttpAttributeRoutes();
            //config.EnableCors();
            var cors = new EnableCorsAttribute("http://localhost:28285", "*", "*");
            config.EnableCors(cors);

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }

 protected void Page_Load(object sender, EventArgs e)
 {
     IUnityContainer container = new UnityContainer();
     UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
     section.Configure(container);
     if (Request["installation"] != null)
     {
         int installationid = Int32.Parse(Request["installation"]);
         userid = Int32.Parse(Request["userid"]);
         user = Request["user"];
         sservice = container.Resolve<IStatisticService>();
         IInstallationBL iinstall = container.Resolve<IInstallationBL>();
         imodel = iinstall.getInstallation(installationid);
         Dictionary<InstallationModel, List<InstallationState>> statelist = sservice.getInstallationState(imodel.customerid);
         StringBuilder str = new StringBuilder();
         str.Append("<table border = '1'><tr><th>Description</th><th>Messwert</th><th>Einheit</th></tr>");
         foreach (var values in statelist)
         {
             if(values.Key.installationid.Equals(installationid))
             {
                 foreach (var item in values.Value)
                 {
                      str.Append("<tr><td>" + item.description + "</td><td>" + item.lastValue + "</td><td>" + item.unit + "</td></tr>");
                 }
                 break;
             }
         }
         str.Append("</table>");
         anlagenzustand.InnerHtml = str.ToString();
     }
 }

        public static void RegisterComponents()
        {
            var container = new UnityContainer();

            // register all your components with the container here
            // it is NOT necessary to register your controllers

            // e.g. container.RegisterType<ITestService, TestService>();

            GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
            // repositories injection
            container.RegisterType<IRepository<Item, int>, ItemRepository>();
            container.RegisterType<IRepository<Category, int>, CategoryRepository>();
            container.RegisterType<IRepository<Reservation, int>, ReservationRepository>();
            container.RegisterType<IRepository<Image, int>, ImageRepository>();

            // authentication injection
            container.RegisterType<DbContext, ReservationContext>(new HierarchicalLifetimeManager());
            container.RegisterType<UserManager<User>, ApplicationUserManager>();
            container.RegisterType<ReservationContext>(new HierarchicalLifetimeManager());
            container.RegisterType<ApplicationUserManager>();

            container.RegisterType<ISecureDataFormat<AuthenticationTicket>, SecureDataFormat<AuthenticationTicket>>();
            container.RegisterType<ITextEncoder, Base64TextEncoder>();
            container.RegisterType<IDataSerializer<AuthenticationTicket>, TicketSerializer>();
            container.RegisterType<IDataProtector>(new InjectionFactory(o => new DpapiDataProtectionProvider().Create("ASP.NET Identity")));

            container.RegisterType<IUserStore<User>, UserStore<User>>(new InjectionConstructor(typeof(ReservationContext)));
            container.RegisterType<IAuthenticationManager>(new InjectionFactory(o => HttpContext.Current.GetOwinContext().Authentication));
            container.RegisterType<IOwinContext>(new InjectionFactory(o => HttpContext.Current.GetOwinContext()));
        }

        public static string LoginUser(string username, string password, string response)
        {
            string result = string.Empty;

            try
            {
                if (!IsRobot(response))
                {
                    IUnityContainer container = new UnityContainer();
                    container.RegisterType<AccountMgr>();
                    container.RegisterType<IAccountDacMgr, AccountDacMgr>();

                    AccountMgr accountMgr = container.Resolve<AccountMgr>();

                    accountMgr.UserName = username;
                    accountMgr.Password = password;

                    if (accountMgr.Login())
                    {
                        FormsAuthentication.SetAuthCookie(accountMgr.UserName, false);

                        result = "OK";
                    }
                }
            }
            catch
            {
                throw;
            }

            return result;
        }

        private static IUnityContainer BuildUnityContainer()
        {
            var container = new UnityContainer();

            // Register repository.
            container.RegisterType<IMyBigBroRepository, MyBigBroRepository>(
                new InjectionConstructor(new MyBigBroContext(GetConnectionString())));

            // Register services.
            container.RegisterType<ILocation, Location>();
            container.RegisterType<IStorageServiceAgent, AzureStorageServiceAgent>();
            container.RegisterType<ILocation, Location>();
            container.RegisterType<IWebCamControl, WebCamControl>();
            container.RegisterType<IGeoMarkerService, GeoMarkerService>();
            container.RegisterType<IAccountService, AccountService>();
            container.RegisterType<IFormsAuthenticationService, FormsAuthenticationService>();

            // Register Web API controllers.
            //container.RegisterType<LoginController>();
            container.RegisterType<GeoMarkersController>();
            container.RegisterType<CapturedImagesGeoMarkerController>();
            container.RegisterType<WebCamsController>();

            // Return the populated container.
            return container;
        }

        public void TryResolveShouldReturnNullIfElementNotExist()
        {
            var container = new UnityContainer();

            object dependantA = container.TryResolve<IDependantA>();
            Assert.IsNull(dependantA);
        }

 private static IUnityContainer BuildUnityContainer()
 {
     var container = new UnityContainer();
     container.RegisterType<IHomeService, HomeService>();
     MvcUnityContainer.Container = container;
     return container;
 }

    static async Task AsyncMain()
    {
        #region ContainerConfiguration
        BusConfiguration busConfiguration = new BusConfiguration();
        busConfiguration.EndpointName("Samples.Unity");

        UnityContainer container = new UnityContainer();
        container.RegisterInstance(new MyService());
        busConfiguration.UseContainer<UnityBuilder>(c => c.UseExistingContainer(container));
        #endregion
        busConfiguration.UseSerialization<JsonSerializer>();
        busConfiguration.UsePersistence<InMemoryPersistence>();
        busConfiguration.EnableInstallers();
        busConfiguration.SendFailedMessagesTo("error");

        IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
        try
        {
            IBusSession busSession = endpoint.CreateBusSession();
            await busSession.SendLocal(new MyMessage());
            Console.WriteLine("Press any key to exit");
            Console.ReadKey();
        }
        finally
        {
            await endpoint.Stop();
        }
    }

        private static IUnityContainer BuildUnityContainer()
        {
            var container = new UnityContainer();
            container.LoadConfiguration();

            return container;
        }

        public static void Register(HttpConfiguration config)
        {
            
            // Web API configuration and services
            //
            var container = new UnityContainer();

            //Service registration
            container.RegisterType<ITestService, TestService>(new HierarchicalLifetimeManager());

            //Data repository registration
            container.RegisterType<ITestRepo, TestRepo>(new HierarchicalLifetimeManager());



            config.DependencyResolver = new UnityDiResolver(container);


            // Web API routes - attribute routing
            //
            config.MapHttpAttributeRoutes();

            // Web API routes - conventional routing
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }

        public static void Register(HttpConfiguration config)
        {
            // Dependency resolver for dependency injection
            UnityContainer container = new UnityContainer();
            container.RegisterType<IResearchRepository, ResearchRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IProjectsRepository, ProjectsRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IReferencesRepository, ReferencesRepository>(new HierarchicalLifetimeManager());
            config.DependencyResolver = new UnityResolver(container);

            config.MapHttpAttributeRoutes();

            // API routes
            config.Routes.MapHttpRoute(
             name: "DefaultApi",
             routeTemplate: "api/{controller}/{id}",
             defaults: new { id = RouteParameter.Optional });

            //OData Models
            ODataModelBuilder odataBuilder = new ODataConventionModelBuilder();
            odataBuilder.Namespace = "SpResearchTracker.Models";
            odataBuilder.EntitySet<Project>("Projects");
            odataBuilder.EntitySet<Reference>("References");

            // OData routes
            config.Routes.MapODataRoute(
              routeName: "odata",
              routePrefix: "odata",
              model: odataBuilder.GetEdmModel(),
              batchHandler: new BreezeODataBatchHandler(GlobalConfiguration.DefaultServer));
        }

 public void Register(UnityContainer container)
 {
     container
         .ConfigureAutoRegistration()
         .Include(x => x.Assembly == Assembly.GetExecutingAssembly(), Then.Register().AsAllInterfacesOfType().UsingPerCallMode())
         .ApplyAutoRegistration();
 }

        /// <summary>
        /// Application Entry Point
        /// </summary>
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            //*************************************************************
            AppDomain.CurrentDomain.UnhandledException +=
                delegate(object sender, UnhandledExceptionEventArgs e)
                {
                    Logging.LogManagerProvider.Instance.WriteError(e.ExceptionObject as Exception);
                };

            //logging initialization
            Logging.LogManagerProvider.Initialize("LoggingSection");

            //Repository and controller initialization
            UnityContainer container = new UnityContainer();
            RepositoryProvider.Register(container, "RepositoryProvider");
            GlobalConfiguration.Configuration.DependencyResolver = new Unity.WebApi.UnityDependencyResolver(container);
            //*************************************************************
        }

        private UnityContainer RegisterUnityContainer()
        {
            var container = new UnityContainer();
            container.LoadConfiguration();

            return container;
        }

        public static void Resolve(UnityContainer container)
        {
            container.RegisterType<DataBaseContext, DataBaseContext>(new HierarchicalLifetimeManager());
            container.RegisterType<IUsuarioService, UsuarioService>(new HierarchicalLifetimeManager());
            container.RegisterType<IUsuarioRepository, UsuarioRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IPermissaoRepository, PermissaoRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IGrupoPermissaoRepository, GrupoPermissaoRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IAutenticacao, AutenticacaoService>(new HierarchicalLifetimeManager());

            container.RegisterType<IPessoaService, PessoaService>(new HierarchicalLifetimeManager());
            container.RegisterType<IPessoaRepository, PessoaRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IPapelRepository, PapelRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IPessoaFisicaRepository, PessoaFisicaRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IPessoaJuridicaRepository, PessoaJuridicaRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IMeioComunicacaoRepository, MeioComunicacaoRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IEnderecoRepository, EnderecoRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IEstadoCivilRepository, EstadoCivilRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IEstadoRepository, EstadoRepository>(new HierarchicalLifetimeManager());

            container.RegisterType<IProdutoService, ProdutoService>(new HierarchicalLifetimeManager());
            container.RegisterType<IProdutoRepository, ProdutoRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IUnidadeRepository, UnidadeRepository>(new HierarchicalLifetimeManager());

            container.RegisterType<ICondicaoPagamentoService, CondicaoPagamentoService>(new HierarchicalLifetimeManager());
            container.RegisterType<IFormaPagamentoService, FormaPagamentoService>(new HierarchicalLifetimeManager());
            container.RegisterType<ICondicaoPagamentoRepository, CondicaoPagamentoRepository>(new HierarchicalLifetimeManager());
            container.RegisterType<IFormaPagamentoRepository, FormaPagamentoRepository>(new HierarchicalLifetimeManager());

            //container.RegisterType<User, User>(new HierarchicalLifetimeManager());
        }

        public void Test()
        {
            using (var container = new UnityContainer())
            {
                container.RegisterType<ITestClass, TestClass>();
                container.AddNewExtension<LazyExtension>();

                var testClass1 = container.Resolve<Lazy<ITestClass>>();

                Assert.AreEqual(false, testClass1.IsValueCreated);
                Assert.AreEqual(0, TestClass.InstanceCount);

                Assert.AreEqual(5, testClass1.Value.HighFive());
                Assert.AreEqual(true, testClass1.IsValueCreated);
                Assert.AreEqual(1, TestClass.InstanceCount);

                var testClass2 = container.Resolve<Lazy<ITestClass>>();

                Assert.AreEqual(false, testClass2.IsValueCreated);
                Assert.AreEqual(1, TestClass.InstanceCount);

                Assert.AreEqual(5, testClass2.Value.HighFive());
                Assert.AreEqual(true, testClass2.IsValueCreated);
                Assert.AreEqual(2, TestClass.InstanceCount);
            }
        }

        public void InjectClassWithTwoConstructors()
        {
            int myInt = 37;
            string myStr = "Test";

            IUnityContainer container = new UnityContainer();

            //constructor without params
            container.Configure<InjectedMembers>().ConfigureInjectionFor<TestClass>(new InjectionConstructor());

            TestClass withOutCon = container.Resolve<TestClass>();
            Assert.IsFalse(withOutCon.StringConstructorCalled);
            Assert.IsFalse(withOutCon.IntConstructorCalled);
            //constructor with one param
            container.Configure<InjectedMembers>()
                .ConfigureInjectionFor<TestClass>("First",
                    new InjectionConstructor(myInt));

            TestClass myTestClass = container.Resolve<TestClass>("First");

            Assert.IsFalse(myTestClass.StringConstructorCalled);
            Assert.IsTrue(myTestClass.IntConstructorCalled);

            //constructor with one param
            container.Configure<InjectedMembers>()
               .ConfigureInjectionFor<TestClass>("Second",
                   new InjectionConstructor(myStr));

            TestClass myTestClass1 = container.Resolve<TestClass>("Second");
            
            Assert.IsFalse(myTestClass1.IntConstructorCalled);
            Assert.IsTrue(myTestClass1.StringConstructorCalled);
        }

        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services registration

            var container = new UnityContainer();

            var dataAccessRegistration = new DataAccessRegistration();
            var repositoryRegistation = new RepositoryRegistration();
            var serviceRegistration = new ServiceRegistration();

            dataAccessRegistration.Register(container);
            repositoryRegistation.Register(container);
            serviceRegistration.Register(container);

            config.DependencyResolver = new UnityResolver(container);

            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
            config.Formatters.JsonFormatter.UseDataContractJsonSerializer = false;

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }

 private void RegisterUnityContainer()
 {
     var container = new UnityContainer();
     container.RegisterType<IPkgOrderService, PkgOrderService>(new PerThreadLifetimeManager())
                   .RegisterType<IDALContext, PkgOrderDALContext>();
     DependencyResolver.SetResolver(new UnityDependencyResolver(container));
 }

        static void Main(string[] args)
        {
            using (UnityContainer container = new UnityContainer())
            {
                ContainerBootstrapper.RegisterTypes(container);

                Application consoleApp = new Application();
                consoleApp.Title = "WELCOME! This program will help you test the Files REST service.";

                foreach (string commandType in new string[] {
                    "UploadCommand",
                    "GetAllMetadataCommand",
                    "GetMetadataCommand",
                    "DownloadAllCommand",
                    "DownloadCommand",
                    "DeleteCommand",
                    "SettingsCommand"
                })
                {
                    Commands.BaseCommand command = container.Resolve<Commands.BaseCommand>(commandType);
                    consoleApp.AddCommand(command);
                }

                Starter.Start(consoleApp);
            }
        }