/// <summary> /// Starts the application. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="EventArgs"/> that contains the event data.</param> protected void Application_Start(object sender, EventArgs e) { IConfigurationSource config = ConfigurationSourceFactory.Create(); Logger.SetLogWriter(new LogWriterFactory(config).Create()); ExceptionPolicy.SetExceptionManager(new ExceptionPolicyFactory(config).CreateManager()); try { IUnityContainer container = new UnityContainer().LoadConfiguration(); container.AddNewExtension<SecurityDependencyContainer>(); container.AddNewExtension<WorflowDependencyContainer>(); DependencyInjectionContainer = container; JsonConvert.DefaultSettings = () => new JsonSerializerSettings { Formatting = Formatting.None, ContractResolver = new DiscretionalContractResolver(), Converters = new JsonConverter[] { new JsonKnownTypeConverter() } }; } catch (Exception ex) { bool rethrow = ExceptionPolicy.HandleException(ex, "Default"); if (rethrow) { throw; } } }
static ApiSetup() { try { //Create Container = new UnityContainer(); Locator = new UnityServiceLocator(Container); //Add entlib extensions Container.AddNewExtension<EnterpriseLibraryCoreExtension>(); #pragma warning disable 612,618 Container.AddNewExtension<CachingBlockExtension>(); #pragma warning restore 612,618 ServiceLocator.SetLocatorProvider(() => Locator); Container.LoadConfiguration("api"); ApiDefaultConfig.DoDefaultRegistrations(Container); //NOTE: disabled for now //try //{ // ApiDefaultConfig.DoAutomaticConfiguration(Container); // Initialization.Add(ApiSetupState.UnityAutoRegitrations, null); //} //catch (Exception e) //{ // Initialization.Add(ApiSetupState.UnityAutoRegitrations, new[] { e }); //} } catch (Exception e) { Initialization.Add(ApiSetupState.UnityRegitrations, new[] { e }); throw; } Initialization.Add(ApiSetupState.UnityRegitrations, null); }
public static UnityContainer Configure() { var container = new UnityContainer(); container.AddNewExtension<DataModule>(); container.AddNewExtension<ProvidersModule>(); container.AddNewExtension<ServiceModule>(); container.AddNewExtension<AnalyticsModule>(); return container; }
public static IDependencyInjectionContainer Compose() { var container = new UnityContainer(); container.AddNewExtension<MvcSiteMapProviderContainerExtension>(); container.AddNewExtension<MvcDemosContainerExtension>(); GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container); return new UnityDependencyInjectionContainer(container); }
public static void RegisterComponents() { var container = new UnityContainer(); container.AddNewExtension<QueriesExtension>(); container.AddNewExtension<AuthenticationExtension>(); container.AddNewExtension<CommandsExtension>(); container.AddNewExtension<CommonServicesExtension>(); container.AddNewExtension<WorkflowsExtension>(); DependencyResolver.SetResolver(new UnityDependencyResolver(container)); }
protected void Application_Start() { XmlConfigurator.Configure(); var container = new UnityContainer(); container.AddNewExtension<Bootstrapper>(); GlobalConfiguration.Configure(WebApiConfig.Register); }
public static void Main() { XmlConfigurator.Configure(); var settings = new Settings(); var container = new UnityContainer(); container.AddNewExtension<Bootstrapper>(); HostFactory.Run(c => { c.UseUnityContainer(container); c.UseLog4Net(); c.SetServiceName(settings.ServiceName); c.SetDisplayName(settings.ServiceDisplayName); c.SetDescription(settings.ServiceDescription); c.Service<ServiceStarter>(s => { s.ConstructUsingUnityContainer(); s.WhenStarted(pcs => pcs.Start()); s.WhenStopped(_ => { }); }); }); System.Console.ReadKey(); }
protected override void OnStartup(StartupEventArgs e) { IUnityContainer container = new UnityContainer(); container.AddNewExtension<LazySupportExtension>(); // Register grooveshark related stuff container.RegisterType<IGroovesharkClient, GroovesharkClientWrapper>( new ContainerControlledLifetimeManager(), new InjectionMethod("Connect")); container.RegisterType<ISongProvider, GroovesharkSongProvider>( GroovesharkSongProvider.ProviderName, new ContainerControlledLifetimeManager()); container.RegisterType<ISongPlayer, GroovesharkSongPlayer>( GroovesharkSongProvider.ProviderName, new ContainerControlledLifetimeManager()); // Register spotify/torshify related stuff container.RegisterType<ISongProvider, SpotifySongProvider>( SpotifySongProvider.ProviderName, new ContainerControlledLifetimeManager()); container.RegisterType<ISongPlayer, TorshifySongPlayerClient>( SpotifySongProvider.ProviderName, new ContainerControlledLifetimeManager()); container.RegisterType<ISpotifyImageProvider, TorshifyImageProvider>(); // Aggregate provider that combines Grooveshark and Spotify players and providers container.RegisterType<ISongProvider, AggregateSongProvider>(new InjectionFactory(c => { var a = new AggregateSongProvider( c.Resolve<ISongProvider>(GroovesharkSongProvider.ProviderName), c.Resolve<ISongProvider>(SpotifySongProvider.ProviderName)); a.UnhandledException += (sender, args) => { Trace.WriteLine(args.Exception); args.Handled = true; }; return a; })); container.RegisterType<ISongPlayer, AggregateSongPlayer>(new InjectionFactory(c => { return new AggregateSongPlayer( c.Resolve<ISongPlayer>(GroovesharkSongProvider.ProviderName), c.Resolve<ISongPlayer>(SpotifySongProvider.ProviderName)); })); TorshifyServerProcessHandler torshifyServerProcess = new TorshifyServerProcessHandler(); torshifyServerProcess.CloseServerTogetherWithClient = true; //torshifyServerProcess.Hidden = true; torshifyServerProcess.TorshifyServerLocation = Path.Combine(Environment.CurrentDirectory, "TRock.Music.Torshify.Server.exe"); torshifyServerProcess.UserName = "******"; torshifyServerProcess.Password = "******"; torshifyServerProcess.Start(); var provider = container.Resolve<ISongProvider>(); MainWindow = container.Resolve<MainWindow>(); MainWindow.Show(); }
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 Setup() { container = new UnityContainer(); container.AddNewExtension<Interception>(); container.RegisterTypeWithCallHandler<ArgumentNotNullHandler, ArgumentNotNullTest>(); sample = container.Resolve<ArgumentNotNullTest>(); }
public void MassDisposable_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<DisposableClass>(new DisposingTransientLifetimeManager()); var sw = new Stopwatch(); sw.Start(); var objects = new List<DisposableClass>(); for (int i = 0; i < 10000; i++) { objects.Add(container.Resolve<DisposableClass>()); } sw.Stop(); Context.WriteLine("Resolve: " + sw.Elapsed.ToString()); sw.Restart(); for (int i = 0; i < 10000; i++) { container.Teardown(objects[i]); Assert.IsTrue(objects[i].Disposed); } sw.Stop(); Context.WriteLine("Teardown: " + sw.Elapsed.ToString()); }
public static IDependencyInjectionContainer Compose() { var container = new UnityContainer(); container.AddNewExtension<MvcSiteMapProviderContainerExtension>(); return new UnityDependencyInjectionContainer(container); }
public void Combined_Test() { var container = new UnityContainer(); container.AddNewExtension<DisposableStrategyExtension>(); container.RegisterType<DisposableClass>("transient", new DisposingTransientLifetimeManager()); container.RegisterType<DisposableClass>("shared", new DisposingSharedLifetimeManager()); var transient1 = container.Resolve<DisposableClass>("transient"); var transient2 = container.Resolve<DisposableClass>("transient"); Assert.AreNotEqual(transient1, transient2); var shared1 = container.Resolve<DisposableClass>("shared"); Assert.AreNotEqual(transient1, shared1); Assert.AreNotEqual(transient2, shared1); var shared2 = container.Resolve<DisposableClass>("shared"); Assert.AreEqual(shared1, shared2); container.Teardown(transient1); Assert.IsTrue(transient1.Disposed); container.Teardown(shared2); Assert.IsFalse(shared2.Disposed); container.Teardown(shared1); Assert.IsTrue(shared1.Disposed); }
public void UnityCanResolveEnumerableOfTypesRegisteredInUnityTest() { // Setup var unityContainer = new UnityContainer(); // Add composition support for unity unityContainer.AddNewExtension<LazySupportExtension>(); Component1.InstanceCount = 0; Component2.InstanceCount = 0; unityContainer.RegisterType<IComponent, Component1>("component1"); unityContainer.RegisterType<IComponent, Component2>("component2"); unityContainer.RegisterType<IComponent, Component3>(); var collectionOfLazyUnityComponents = unityContainer.Resolve<IEnumerable<IComponent>>(); Assert.That(collectionOfLazyUnityComponents, Is.Not.Null); Assert.That(Component1.InstanceCount, Is.EqualTo(1)); Assert.That(Component2.InstanceCount, Is.EqualTo(1)); var list = new List<IComponent>(collectionOfLazyUnityComponents); Assert.That(list.Count, Is.EqualTo(3)); Assert.That(list.OfType<Component1>().Count(), Is.EqualTo(1)); Assert.That(list.OfType<Component2>().Count(), Is.EqualTo(1)); Assert.That(list.OfType<Component3>().Count(), Is.EqualTo(1)); }
public static void RegisterRepositoryTypes(UnityContainer container) { /* Register types into the container */ container.RegisterType<IDataService, DataService>(); //container.RegisterType<IDataService, DummyDataService>(); /* Register the Logger to be used by all calls from the container */ container.RegisterType<LogHelper, LogHelper>(new ContainerControlledLifetimeManager()); /* Register our data access helper to be used uniquely for each thread call from container */ container.RegisterType<IDataAccessor, DataAccessor>(new PerThreadLifetimeManager()); /* Register our matching rule and call handlers (AKA Aspects) */ container.RegisterType<IMatchingRule, AllMatchingRule>(MatchingRule); container.RegisterType<ICallHandler, ExceptionCallHandler>(ExceptionCallHandler.Key); container.RegisterType<ICallHandler, UnitOfWorkCallHandler>(UnitOfWorkCallHandler.Key); container.RegisterType<ICallHandler, AuthenticationCallHandler>(AuthenticationCallHandler.Key); container.RegisterType<ICallHandler, CommandCallHandler>(CommandCallHandler.Key); container.RegisterType<ICallHandler, LogCallHandler>(LogCallHandler.Key); /* Create a new policy and reference the matching rule and call handler by name */ container.AddNewExtension<Interception>(); container.Configure<Interception>() .AddPolicy(PolicyName) .AddMatchingRule(MatchingRule) .AddCallHandler(ExceptionCallHandler.Key) .AddCallHandler(UnitOfWorkCallHandler.Key) //.AddCallHandler(LogCallHandler.Key) .AddCallHandler(AuthenticationCallHandler.Key) .AddCallHandler(CommandCallHandler.Key); /* Make IDataService interface elegible for interception */ container.Configure<Interception>().SetInterceptorFor(typeof(IDataService), new TransparentProxyInterceptor()); }
protected override WorkflowServiceHost CreateWorkflowServiceHost(WorkflowService service, Uri[] baseAddresses) { var container = new UnityContainer(); ConfigureContainer(container); var host = base.CreateWorkflowServiceHost(service, baseAddresses); var injectionType = ConfigureInjectionType(); if (injectionType == InjectionTypes.Push) { container.AddNewExtension<WorkflowExtension>(); var rootActivity = host.Activity; container.BuildUp(rootActivity.GetType(), rootActivity); } else { var diExtension = new DependencyInjectionExtension(container); host.WorkflowExtensions.Add(diExtension); } ConfigureServiceHost(host); return host; }
static void Main(string[] args) { IUnityContainer container = new UnityContainer(); container.AddNewExtension<TypeTrackingExtension>(); container.RegisterType<IFoo, AFoo>(); container.RegisterType<IFoo, AnotherFoo>("Named"); Console.WriteLine("CanResolve<IFoo>() == {0}", container.CanResolve<IFoo>()); Console.WriteLine("CanResolve<IFoo>(\"Named\") == {0}", container.CanResolve<IFoo>("Named")); Console.WriteLine("CanResolve<IBar>() == {0}", container.CanResolve<IBar>()); Console.WriteLine("TryResolve<IFoo>() == null ==> {0}", container.TryResolve<IFoo>() == null); Console.WriteLine("TryResolve<IFoo>(\"Named\") == null ==> {0}", container.TryResolve<IFoo>("Named") == null); Console.WriteLine("TryResolve<IBar>() == null ==> {0}", container.TryResolve<IBar>() == null); Console.WriteLine("TryResolve<IBar>(new ABar()) == null ==> {0}", container.TryResolve<IBar>(new ABar()) == null); Console.WriteLine("TryResolve<IBar>(\"Named\", new ABar()) == null ==> {0}", container.TryResolve<IBar>("Named", new ABar()) == null); Console.WriteLine("ResolveAllToEnumerable<IFoo>().Count() == {0}", container.ResolveAllToEnumerable<IFoo>().Count()); Console.WriteLine("ResolveAllToEnumerable<IFoo>(false).Count() == {0}", container.ResolveAllToEnumerable<IFoo>(false).Count()); Console.WriteLine("ResolveAllToEnumerable<IBar>().Count() == {0}", container.ResolveAllToEnumerable<IBar>().Count()); Console.WriteLine("ResolveAllToArray<IFoo>().Length == {0}", container.ResolveAllToArray<IFoo>().Length); Console.WriteLine("ResolveAllToArray<IFoo>(false).Length == {0}", container.ResolveAllToArray<IFoo>(false).Length); Console.WriteLine("ResolveAllToArray<IBar>().Length == {0}", container.ResolveAllToArray<IBar>().Length); Console.ReadLine(); }
public void AddMyCustonExtensionToContainer() { IUnityContainer uc = new UnityContainer(); uc.AddNewExtension<MyCustomExtension>(); Assert.IsNotNull(uc); }
static void UsingPIABWithContainer() { ConfigureLogger(); using (var container = new UnityContainer()) { container.AddNewExtension<Interception>(); container.RegisterType<InterceptableTenantStore>(new Interceptor<TransparentProxyInterceptor>(), new InterceptionBehavior<PolicyInjectionBehavior>()); container.Configure<Interception>().AddPolicy("logging") .AddMatchingRule<MemberNameMatchingRule>( new InjectionConstructor( new InjectionParameter("Save"))) .AddCallHandler<LogCallHandler>( new ContainerControlledLifetimeManager(), new InjectionConstructor( 9001, true, false, "This is before the method call", "This is after the method call", false, false, true, 10, 1)); var tenantStore = container.Resolve<InterceptableTenantStore>(); // Use the interceptable type. Console.WriteLine("*** Invoking the Save method ***"); tenantStore.Save(); Console.WriteLine("*** Invoking the Modify method ***"); tenantStore.Modify(); } }
public void Setup() { container = new UnityContainer(); container.AddNewExtension<Interception>(); CallHandlerInitialiser.RegisterCallHandlerDependencies(container); HandlerHelpers.RegisterTypeWithCallHandler<TimingHandler, SampleTimingClass>(container); publisher = container.Resolve<IMethodTimePublisher>(); }
public void ConfigureContainerbyAddingExteralPolicy() { IUnityContainer container = new UnityContainer(); container.AddNewExtension<Interception>(); container.Configure<Interception>().AddPolicy("myRDP"); List<InjectionPolicy> policy = new List<InjectionPolicy>(container.ResolveAll<InjectionPolicy>()); Assert.AreEqual("myRDP", policy[1].Name); }
public static IUnityContainer Init() { IUnityContainer container = new UnityContainer(); container.AddNewExtension<Interception>(); container.RegisterType<IDummyService, DummyService2>(); container.SetUpForLogging<IDummyService, DummyService2>(); return container; }
public static void RegisterDependencies() { var container = new UnityContainer(); container.AddNewExtension<UnityDepenencyExtension>(); var controllerFactory = new UnityControllerFactory(container); ControllerBuilder.Current.SetControllerFactory(controllerFactory); }
public void TestStepScopeProperty1() { IUnityContainer container = new UnityContainer(); container.AddNewExtension<StepScopeExtension>(); container.RegisterSingleton<A>("a", new InjectionConstructor(), new InjectionProperty("I", new ResolvedParameter<B>("i"))); container.RegisterStepScope<B>("i"); Check(container); }
public void TestAOPWithPIAB() { var container = new UnityContainer(); container.RegisterType<IEmployeeBusinessObject, EmployeeBusinessObject>(new InjectionConstructor()); container.AddNewExtension<EnterpriseLibraryCoreExtension>(); var ebo = container.Resolve<IEmployeeBusinessObject>(); Assert.NotNull(ebo); }
public void Unity_Dynamic_Interceptor_Test() { IUnityContainer container = new UnityContainer(); container.AddNewExtension<Interception>() .RegisterType<IMockInterceptorObject, MockInterceptorObject>() .Configure<Interception>().SetInterceptorFor<IMockInterceptorObject>(new InterfaceInterceptor()); container.Resolve<IMockInterceptorObject>().Say(); }
public void ConfigureContainerbyAddingEmptyHandlerRuleThrowException() { IUnityContainer container = new UnityContainer(); container.AddNewExtension<Interception>(); container.Configure<Interception>(). AddPolicy("myRDP"). AddCallHandler(String.Empty). AddMatchingRule(String.Empty); List<InjectionPolicy> policy = new List<InjectionPolicy>(container.ResolveAll<InjectionPolicy>()); }
public static void RegisterComponents() { var container = new UnityContainer(); var allClasses = AllClasses.FromAssemblies(BuildManager.GetReferencedAssemblies().Cast<Assembly>()); container.RegisterTypes(allClasses, WithMappings.FromMatchingInterface, WithName.Default); container.AddNewExtension<MapsContainerExtension>(); GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container); }
public static IUnityContainer Init() { IUnityContainer container = new UnityContainer(); container.AddNewExtension<Interception>(); container.RegisterType<IGreeter, Aussie>("Aussie"); container.RegisterType<IGreeter, Kiwi>("Kiwi"); container.RegisterType<IGreeter, Pom>("Pom"); container.SetUpForLogging<IGreeter, Aussie>(); return container; }
// Use this for initialization void Start() { IUnityContainer container = new UnityContainer(); container.AddNewExtension<Interception>(); container.RegisterType<ICharacterManager, CharacterManager> ( new Interceptor<InterfaceInterceptor>(), new InterceptionBehavior<ExceptionInterceptionBehavior>() ); }