static void Extend(IUnityContainer container) { container.AddExtension(new TypeTracker()); container.AddExtension(new CycleDetector()); container.AddExtension(new InjectionPolicies()); container.AddExtension(new TypeRegistrationRequired()); }
public void CanCreatePoliciesForHandler() { ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy"); settings.ExceptionPolicies.Add(exceptionPolicyData); ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException); exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData); ExceptionHandlerData exceptionHandlerData = new ReplaceHandlerData("handler1", "replaced", typeof(ArgumentException).AssemblyQualifiedName); exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData); container.AddExtension(new ExceptionHandlingBlockExtension()); ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy"); Exception originalException = new Exception("to be replaced"); try { policy.HandleException(originalException); Assert.Fail("a new exception should have been thrown"); } catch (ArgumentException e) { Assert.AreEqual("replaced", e.Message); Assert.IsNull(e.InnerException); } }
public void Baseline() { // Act Container.AddExtension(extension1); // Validate Assert.AreSame(Container, extension1.ExtensionContext.Container); Assert.IsNotNull(extension1.ExtensionContext.Policies); }
public void SafeBehaviorPreventsExceptionOnRegisterInstance() { Container.RemoveAllExtensions(); Container.AddExtension(new UnitySafeBehaviorExtension()); Container.AddExtension(new InjectedMembers()); Container.AddExtension(new UnityDefaultStrategiesExtension()); Container.RegisterInstance <ITest>(this); Assert.AreEqual(0, FirstChanceExceptions.Count); }
public void CanCreatePoliciesForTextFormatter() { FormatterData data = new TextFormatterData("name", "template"); loggingSettings.Formatters.Add(data); container.AddExtension(new LoggingBlockExtension()); TextFormatter createdObject = (TextFormatter)container.Resolve <ILogFormatter>("name"); Assert.IsNotNull(createdObject); Assert.AreEqual("template", createdObject.Template); }
internal override void Execute(IUnityContainer container) { if (decoratorFunc != null) { container.AddExtension(new DecoratorExtension <T>(decoratorFunc)); } if (action != null) { container.AddExtension(new PostBuildUpActionExtension <T>(action)); } }
public void ExtensionPopulatesTheConfigurationSourcePolicy() { IConfigurationSource theAvailableConfigurationSource = null; container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource)); container.AddExtension(new TestHelperExtension( c => { theAvailableConfigurationSource = c.Policies.Get <IConfigurationObjectPolicy>(typeof(IConfigurationSource)).ConfigurationSource; })); Assert.AreSame(configurationSource, theAvailableConfigurationSource); }
public static void RegisterTypes(IUnityContainer container) { container.AddNewExtension <Interception>(); Container.RegisterType <ToDoListEntities>(new Unity.Lifetime.SingletonLifetimeManager()); container.AddExtension(new RegisterModule()); container.AddExtension(new RepositoryRegisterModule()); container.AddExtension(new ServiceRegisterModule()); container.AddNewExtension <Interception>(); }
public void ExceptionHandledThroughLoggingBlock() { MockTraceListener.Reset(); container.AddExtension(new ExceptionHandlingBlockExtension()); container.AddExtension(new LoggingBlockExtension()); ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("Logging Policy"); Assert.IsFalse(policy.HandleException(new Exception("TEST EXCEPTION"))); Assert.AreEqual(1, MockTraceListener.LastEntry.Categories.Count); Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains("TestCat")); Assert.AreEqual(5, MockTraceListener.LastEntry.EventId); Assert.AreEqual(TraceEventType.Error, MockTraceListener.LastEntry.Severity); Assert.AreEqual("TestTitle", MockTraceListener.LastEntry.Title); }
public void CanCreatePoliciesForHandler() { ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy"); settings.ExceptionPolicies.Add(exceptionPolicyData); ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException); exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData); FaultContractExceptionHandlerData exceptionHandlerData = new FaultContractExceptionHandlerData("handler1", typeof(MockFaultContract).AssemblyQualifiedName); exceptionHandlerData.ExceptionMessage = "fault message"; exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("Message", "{Message}")); exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("Data", "{Data}")); exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("SomeNumber", "{OffendingNumber}")); exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData); container.AddExtension(new ExceptionHandlingBlockExtension()); ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy"); NotFiniteNumberException originalException = new NotFiniteNumberException("MyException", 12341234123412); originalException.Data.Add("someKey", "someValue"); try { policy.HandleException(originalException); Assert.Fail("a new exception should have been thrown"); } catch (FaultContractWrapperException e) { MockFaultContract fault = (MockFaultContract)e.FaultContract; Assert.AreEqual(originalException.Message, fault.Message); Assert.AreEqual(originalException.Data.Count, fault.Data.Count); Assert.AreEqual(originalException.Data["someKey"], fault.Data["someKey"]); Assert.AreEqual(originalException.OffendingNumber, fault.SomeNumber); } }
protected void Application_Start(object sender, EventArgs e) { // initialize entity framework 6 profiling EFProfilingBootstrapper.Initialize(); #region Optional bootstrap code for unity based deep profiling and policy injection based profiling // Register types to unity container to demo unity based deep profiling & policy injection based profiling. Container.RegisterType <IDemoDBDataService, DemoDBDataService>( new ContainerControlledLifetimeManager() , new InterceptionBehavior <PolicyInjectionBehavior>()); //enable policy injection Container.RegisterType <IDemoDBService, DemoDBService>(new ContainerControlledLifetimeManager()); // Enable policy injection for interface types registered with PolicyInjectionBehavior Container.AddNewExtension <Interception>() .Configure <Interception>() .SetDefaultInterceptorFor <IDemoDBDataService>(new InterfaceInterceptor()); // Enable deep profiling extension for profiling any interface methods on // interface types containing "DemoDBService". // When deep profiling is enabled on specified types, policy injection will be ignored. Container.AddExtension(new DeepProfilingExtension(new RegexDeepProfilingFilter(new Regex("DemoDBService")))); #endregion }
/// <summary> /// Installs extensions to the container. /// </summary> /// <param name="container">Container to modify</param> /// <param name="extensions">Extensions to install</param> public static void InstallExtensions(this IUnityContainer container, IEnumerable <UnityContainerExtension> extensions) { foreach (var extension in extensions) { container.AddExtension(extension); } }
protected ViewModelLocator() { _unityContainer = new UnityContainer(); _unityContainer.AddExtension(new Diagnostic()); // Providers // Services _unityContainer.RegisterType <IDialogService, DialogService>(); RegisterSingleton <INavigationService, NavigationService>(); _unityContainer.RegisterType <IDeserializer, JsonSerializer>(); _unityContainer.RegisterType <IErrorLogger, ErrorLogger>(); //DataServices _unityContainer.RegisterType <BaseClient>(); _unityContainer.RegisterType <UserDataService>(); _unityContainer.RegisterType <MagazineDataService>(); _unityContainer.RegisterType <AbonnementDataService>(); _unityContainer.RegisterType <PaiementDataService>(); // View models _unityContainer.RegisterType <LoginViewModel>(); _unityContainer.RegisterType <AccountViewModel>(); _unityContainer.RegisterType <NonAbonnementsViewModel>(); _unityContainer.RegisterType <AbonnementsViewModel>(); _unityContainer.RegisterType <MagazineViewModel>(); _unityContainer.RegisterType <PayementViewModel>(); _unityContainer.RegisterType <ButtonSubscribedMagazineViewModel>(); _unityContainer.RegisterType <ButtonSubscribeMagazineViewModel>(); _unityContainer.RegisterType <MainViewModel>(); }
/// <summary> /// Add the extension specified in this element to the container. /// </summary> /// <param name="container">Container to configure.</param> protected override void ConfigureContainer(IUnityContainer container) { var extensionType = GetExtensionType(); var extension = (UnityContainerExtension)container.Resolve(extensionType); container.AddExtension(extension); }
public UnityDependencyEngine() { _container = new UnityContainer(); var unityDecoratorExtension = new UnityDecoratorExtension(); _container.AddExtension(unityDecoratorExtension); }
private void RegisterExtension(string assemblyName, string className) { Assembly asm = Load(assemblyName); ContainerExtension extensions = (ContainerExtension)asm.CreateInstance(className); _Container.AddExtension(extensions); }
static void Main(string[] args) { var ext = new NLogExtension() { GetName = (t, n) => t.FullName }; _container = new UnityContainer(); _container.AddExtension(ext). RegisterType <ITestComponent, Baranina>("baranina"). RegisterType <ITestComponent, Cielecina>("cielecina"). RegisterType <ITestConstructorInjection, TestConstructorInjection>(); var _instance = _container.Resolve <Class1>(); _instance.GetName += GetName; _instance.GetName += GetName2; _instance.GetName += GetName3; _instance.GetName += GetName4; _instance.TestLogging(); ITestComponent baranina = _container.Resolve <Baranina>(); baranina.GetName(); var bar2 = _container.Resolve <ITestComponent>("baranina"); ITestComponent cielecina = _container.Resolve <Cielecina>(); cielecina.GetName(); Console.ReadLine(); }
public void AddExtension(UnityContainerExtension extensionModule) { if (extensionModule != null) { _container.AddExtension(extensionModule); } }
/// <summary> /// Registers the type mappings with the Unity container. /// </summary> /// <param name="container">The unity container to configure.</param> /// <remarks> /// There is no need to register concrete types such as controllers or /// API controllers (unless you want to change the defaults), as Unity /// allows resolving a concrete type even if it was not previously /// registered. /// </remarks> public static void RegisterTypes(IUnityContainer container) { container.RegisterType <Services.ISessionService, Services.SessionService>(new PerRequestLifetimeManager()); var connectionString = ConfigurationManager.ConnectionStrings["DataBaseConnection"].ConnectionString; container.AddExtension(new ApplicationExtension(connectionString)); }
/// <summary> /// Add the extensions needed to make everything works. Including EnumerableExtensions. /// </summary> /// <param name="container"></param> /// <returns></returns> public static IUnityContainer WithAspNetCoreServiceProvider(this IUnityContainer container) { container.RegisterType <IServiceProvider, UnityServiceProvider>(); container.RegisterType <IServiceScopeFactory, UnityServiceScopeFactory>(); return(container.AddExtension(new EnumerableExtension()).AddExtension(new CustomBuildExtension())); }
/// <summary> /// Creates a new extension object and adds it to the container. /// </summary> /// <typeparam name="TExtension">Type of <see cref="UnityContainerExtension"/> to add. The extension type /// will be resolved from within the supplied <paramref name="container"/>.</typeparam> /// <param name="container">Container to add the extension to.</param> /// <returns>The <see cref="Unity.IUnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns> public static IUnityContainer AddNewExtension <TExtension>(this IUnityContainer container) where TExtension : UnityContainerExtension { TExtension newExtension = (container ?? throw new ArgumentNullException(nameof(container))).Resolve <TExtension>(); return(container.AddExtension(newExtension)); }
public static ITypeFactory Boot(string loggerName,Assembly asm) { XmlConfigurator.Configure(); container = new UnityContainer(); RegisterKnownTypes(asm); RegisterKnownTypes(typeof(ITypeFactory).Assembly); container.RegisterInstance<ITypeFactory>(new TypeFactory(container)); container.RegisterInstance<ILog>(LogManager.GetLogger(loggerName)); container.RegisterInstance<ICommandRouter>(new CommandRouterImpl()); factory = container.Resolve<ITypeFactory>(); factory.Get<ILog>().Info(".=.=.=. " + Assembly.GetExecutingAssembly().GetName().Name + " =.=.=.="); factory.Get<ILog>().Info("Version:" + Assembly.GetExecutingAssembly().GetName().Version.ToString()); string dataPath = ApplicationEnvironment.Instance.DataPath; if (!Directory.Exists(dataPath)) { factory.Get<ILog>().Error("L'applicazione non riesce a creare il percorso dati:" + dataPath); } factory.Get<ILog>().Debug("Data path applicazione:"+dataPath); container.AddExtension(new WireImportExports()); return factory; }
public static IUnityContainer AddNewExtension<TExtension>(this IUnityContainer container) where TExtension : UnityContainerExtension { Guard.ArgumentNotNull(container, "container"); TExtension newExtension = container.Resolve<TExtension>(); return container.AddExtension(newExtension); }
public void SetUp() { container = new UnityContainer(); settings = new ExceptionHandlingSettings(); configurationSource = new DictionaryConfigurationSource(); configurationSource.Add(ExceptionHandlingSettings.SectionName, settings); container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource)); }
public void Configure(IUnityContainer container) { Guard.ArgumentNotNull(container, "container"); ConstructorInfo ctor = Type.GetConstructor(Type.EmptyTypes); UnityContainerExtension instance = (UnityContainerExtension)ctor.Invoke(null); container.AddExtension(instance); }
protected override void ConfigureContainer(IUnityContainer container) { Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(container, "container"); var extensionType = this.GetExtensionType(); var extension = (UnityContainerExtension)container.Resolve(extensionType); container.AddExtension(extension); }
public void Setup() { Tests.Init.ServiceCollection.AddTransient <ICalculator, Multiplication>(); _serviceProvider = Init.ServiceCollection.BuildServiceProvider(); _container = new UnityContainer(); _container.AddExtension(new UnityFallbackProviderExtension(_serviceProvider)); }
public void TestInitialize() { container = new UnityContainer(); mr = new MockRepository(); mocknity = new MocknityContainerExtension(mr); container.AddExtension(mocknity); }
public void SetUp() { loggingSettings = new LoggingSettings(); configurationSource = new DictionaryConfigurationSource(); configurationSource.Add(LoggingSettings.SectionName, loggingSettings); container = new UnityContainer(); container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource)); }
public void Run() { _container.AddExtension(new SchedulerUnityExtension()); ConfigureContainer(); ConfigureMvc(); GlobalConfiguration.Configure(ConfigureWebApi); }
public void SetUp() { container = new UnityContainer(); settings = new TestSettings(); configurationSource = new DictionaryConfigurationSource(); configurationSource.Add(settingsKey, settings); container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource)); }
/// <summary> /// Creates the instance of the Unity container. /// </summary> protected override void PreCompose() { unityContainer = new UnityContainer(); var locator = new UnityServiceLocator(unityContainer); exportProvider = new CSLExportProvider(locator); unityContainer.AddExtension(new CSLExportProviderExtension(exportProvider)); RegisterTypes(); }
public void Init(HttpApplication context) { if (_container == null) { var appAsUnityAccessor = (context as IUnityContainerAccessor); if (appAsUnityAccessor == null) throw new Exception("The http application must implement \"Thingie.Tracking.Unity.ASPNET.IUnityContainerAccessor\" for the TrackingModule to work! Please implement the interface in global.asax."); _container = appAsUnityAccessor.Container; RegisterTrackers(_container); _container.AddExtension(new TrackingExtension()); } context.PreRequestHandlerExecute += new EventHandler(context_PreRequestHandlerExecute); context.PostRequestHandlerExecute += new EventHandler(context_PostRequestHandlerExecute); }
protected override void ConfigureContainer(IUnityContainer container) { var interception = new ExtendedInterception(); if (!string.IsNullOrEmpty(Interceptor)) { var type = Type.GetType(Interceptor); if (null == type) { throw new ConfigurationErrorsException(string.Format("The {0} is not a valid Interceptor.", Interceptor)); } if (!typeof (IInterceptor).IsAssignableFrom(type)) { throw new ConfigurationErrorsException(string.Format("The {0} is not a valid Interceptor.", Interceptor)); } interception.Interceptor = (IInterceptor) Activator.CreateInstance(type); } container.AddExtension(interception); }
private void RegisterTypes(IUnityContainer container) { //Register Common unity container var commonContainer = new CommonUnityExtension(); container.AddExtension(commonContainer); }
public void SetUp() { container = new UnityContainer(); container.AddExtension(new EnterpriseLibraryCoreExtension()); }
public virtual void Setup() { Container = new UnityContainer(); MockUnit.Setup(); Container.AddExtension(MockUnit.Extension); }
public void SetUp() { container = new UnityContainer(); container.AddExtension(new EnterpriseLibraryCoreExtension()); CryptographerFixture.CreateKeyFile(keyedHashKeyFile); }