public void SetUp() { hashProviders = new Dictionary <string, IHashProvider>(); symmetricCrytoProviders = new Dictionary <string, ISymmetricCryptoProvider>(); CreateKeyFile(symmetricKeyFile); CreateKeyFile(keyedHashKeyFile); configSource = ConfigurationSourceFactory.Create(); HashProviderFactory factory = new HashProviderFactory(configSource); defaultHashProvider = factory.Create(hashInstance); hashProviders.Add(hashInstance, defaultHashProvider); SymmetricCryptoProviderFactory symmfactory = new SymmetricCryptoProviderFactory(configSource); defaultSymmetricCryptoProvider = symmfactory.Create(symmInstance); algorithSymmetricCryptoProvider = symmfactory.Create(symmetricAlgorithm1); symmetricCrytoProviders.Add(symmInstance, defaultSymmetricCryptoProvider); symmetricCrytoProviders.Add(symmetricAlgorithm1, algorithSymmetricCryptoProvider); var container = EnterpriseLibraryContainer.CreateDefaultContainer(configSource); cryptographyManager = container.GetInstance <CryptographyManager>(); }
static void Main(string[] args) { // 構成情報を組み立てる var builder = new ConfigurationSourceBuilder(); builder.ConfigureLogging() .SpecialSources .AllEventsCategory .SendTo .FlatFile("FlatFileListener") .FormatWith( new FormatterBuilder() .TextFormatterNamed("TextFormatter") .UsingTemplate("{timestamp(local:yyyy/MM/dd HH:mm:ss.fff)}: {message}")) .ToFile("output.txt"); // 組み立てた構成情報からConfigurationSourceを作成 var config = new DictionaryConfigurationSource(); builder.UpdateConfigurationWithReplace(config); // 構成情報を元にEnterpriseLibraryのコンテナの初期化 EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(config); // EnterpriseLibraryのコンテナからLogging Application BlockのLog書き込み部品を取得 var logger = EnterpriseLibraryContainer.Current.GetInstance <LogWriter>(); // ログに出力する logger.Write("Hello world"); // ログを表示 Process.Start("output.txt"); }
void NullEncryptorTests(string instanceName) { MockStorageEncryptionProvider.Encrypted = false; MockStorageEncryptionProvider.Decrypted = false; CacheManagerSettings settings = (CacheManagerSettings)TestConfigurationSource.GenerateConfiguration().GetSection(CacheManagerSettings.SectionName); CacheStorageData cacheStorageData = settings.BackingStores.Get(((CacheManagerData)settings.CacheManagers.Get(instanceName)).CacheStorage); StorageEncryptionProviderData encryptionProviderData = settings.EncryptionProviders.Get(cacheStorageData.StorageEncryption); IStorageEncryptionProvider provider = EnterpriseLibraryContainer.CreateDefaultContainer(TestConfigurationSource.GenerateConfiguration()).GetInstance <IStorageEncryptionProvider>(encryptionProviderData.Name); Assert.IsNotNull(provider); byte[] input = new byte[] { 0, 1, 2, 3, 4, 5 }; byte[] encrypted = provider.Encrypt(input); Assert.IsTrue(MockStorageEncryptionProvider.Encrypted, "static encrypted"); Assert.IsTrue(CompareBytes(input, encrypted), "no encryption performed"); byte[] decrypted = provider.Decrypt(encrypted); Assert.IsTrue(MockStorageEncryptionProvider.Decrypted, "static decrypted"); Assert.IsTrue(CompareBytes(encrypted, decrypted), "no decryption performed"); Assert.IsTrue(CompareBytes(input, decrypted), "no decryption performed2"); }
public void SetLogFilePath(string filePath) { ConfigurationFileMap objConfigPath = new ConfigurationFileMap(); // App config file path. string appPath = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; objConfigPath.MachineConfigFilename = appPath; Configuration entLibConfig = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration("~"); LoggingSettings loggingSettings = (LoggingSettings)entLibConfig.GetSection(LoggingSettings.SectionName); TraceListenerData traceListenerData = loggingSettings.TraceListeners.Get("Flat File Trace Listener"); FlatFileTraceListenerData objFlatFileTraceListenerData = traceListenerData as FlatFileTraceListenerData; objFlatFileTraceListenerData.FileName = filePath; IUnityContainer container = new UnityContainer(); container.AddNewExtension <EnterpriseLibraryCoreExtension>(); // Configurator will read Enterprise Library configuration // and set up the container UnityContainerConfigurator configurator = new UnityContainerConfigurator(container); var loggingXmlConfigSource = new SerializableConfigurationSource(); loggingXmlConfigSource.Add(LoggingSettings.SectionName, loggingSettings); // Configure the container with our own custom logging EnterpriseLibraryContainer.ConfigureContainer(configurator, loggingXmlConfigSource); // Wrap in ServiceLocator IServiceLocator locator = new UnityServiceLocator(container); // And set Enterprise Library to use it EnterpriseLibraryContainer.Current = locator; }
public void CanBuildValidationInstanceFactoryFromGivenConfiguration() { DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource(); ValidationSettings settings = new ValidationSettings(); configurationSource.Add(ValidationSettings.SectionName, settings); ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(BaseTestDomainObject)); settings.Types.Add(typeReference); typeReference.DefaultRuleset = "RuleA"; ValidationRulesetData ruleData = new ValidationRulesetData("RuleA"); typeReference.Rulesets.Add(ruleData); ValidatedPropertyReference propertyReference1 = new ValidatedPropertyReference("Property1"); ruleData.Properties.Add(propertyReference1); MockValidatorData validator11 = new MockValidatorData("validator1", true); propertyReference1.Validators.Add(validator11); validator11.MessageTemplate = "message-from-config1-RuleA"; CompositeValidatorFactory factory = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource) .GetInstance <CompositeValidatorFactory>(); var validator = factory.CreateValidator <BaseTestDomainObject>("RuleA"); var results = validator.Validate(new BaseTestDomainObject()); Assert.IsNotNull(factory); Assert.IsFalse(results.IsValid); Assert.AreEqual(validator11.MessageTemplate, results.ElementAt(0).Message); }
public static UnityContainer Create() { var container = new UnityContainer(); container.InstallCoreExtensions(); // Configurator will read Enterprise Library configuration // and set up the container var configurator = new UnityContainerConfigurator(container); // Configuration source holds the new configuration we want to use // load this in your own code IConfigurationSource configSource = new SystemConfigurationSource(true); // Configure the container EnterpriseLibraryContainer.ConfigureContainer(configurator, configSource); // Self-register and set up service location container.RegisterInstance <IUnityContainer>(container); var locator = new UnityServiceLocator(container); ServiceLocator.SetLocatorProvider(() => locator); return(container); }
/// <summary> /// ConfigurationSourceBuilderの内容を元にIServiceProviderを作成します。 /// </summary> /// <param name="self"></param> /// <returns></returns> public static IServiceLocator CreateContainer(this ConfigurationSourceBuilder self) { var configuration = new DictionaryConfigurationSource(); self.UpdateConfigurationWithReplace(configuration); return(EnterpriseLibraryContainer.CreateDefaultContainer(configuration)); }
protected override void Arrange() { updatableConfigurationSource = new ConfigurationSourceUpdatable(); connectionStringsSection = new ConnectionStringsSection(); connectionStringsSection.ConnectionStrings.Add( new ConnectionStringSettings { Name = "default connection", ConnectionString = "connection string", ProviderName = "System.Data.OracleClient" }); connectionStringsSection.ConnectionStrings.Add( new ConnectionStringSettings { Name = "other connection", ConnectionString = "connection string", ProviderName = "System.Data.SqlClient" }); databaseSettings = new DatabaseSettings { DefaultDatabase = "default connection" }; updatableConfigurationSource.Add("connectionStrings", connectionStringsSection); updatableConfigurationSource.Add(DatabaseSettings.SectionName, databaseSettings); container = new UnityContainer(); containerConfigurator = new UnityContainerConfigurator(container); EnterpriseLibraryContainer.ConfigureContainer(containerConfigurator, updatableConfigurationSource); }
private void ConfigureExceptionHandling() { var configurationSource = new DictionaryConfigurationSource(); var builder = new ConfigurationSourceBuilder(); builder .ConfigureExceptionHandling() .GivenPolicyWithName(ValidationPolicy) .ForExceptionType <DeleteConstraintException>() .HandleCustom <BusinessValidationHandler>() .ThenThrowNewException() .ForExceptionType <BusinessValidationException>() .ThenNotifyRethrow() .ForExceptionType <BusinessException>() .HandleCustom <BusinessValidationHandler>() .ThenThrowNewException() .GivenPolicyWithName(DefaultPolicy) .ForExceptionType <Exception>() .LogToCategory("General") .WithSeverity(TraceEventType.Critical) .UsingExceptionFormatter <TextExceptionFormatter>() .WrapWith <Exception>() .UsingMessage("An error has occurred while processing request. Please contact your administrator for more information. [Error ID: {handlingInstanceID}]") .ThenThrowNewException(); builder.UpdateConfigurationWithReplace(configurationSource); var configurator = new UnityContainerConfigurator(this.Container); EnterpriseLibraryContainer.ConfigureContainer(configurator, configurationSource); }
public void CreateLogger_WithConfiguredLogWriter_LogEntryIsForwardedToConfiguredLogWriter() { /* Create a mocked logwriter */ LogWriter mockedLogWriter = MockRepository.GenerateMock <LogWriter>(); /* Build up the EnterpriseLibraryContainer using Unity for the IoC */ IUnityContainer container = new UnityContainer(); container.RegisterInstance <LogWriter>("logwriter", mockedLogWriter); /* Any name will do */ UnityContainerConfigurator configurator = new UnityContainerConfigurator(container); IConfigurationSource configSource = new DictionaryConfigurationSource(); EnterpriseLibraryContainer.ConfigureContainer(configurator, configSource); IServiceLocator locator = new UnityServiceLocator(container); EnterpriseLibraryContainer.Current = locator; /* Call the test subject */ Logger result = LogManager.CreateLogger(); /* Make sure the returned logger is not null... */ Assert.IsNotNull(result); /* ...and that the returned logger is working with the configured LogWriter */ LogEntry entry = new LogEntry("message", "category", 1, 1000, System.Diagnostics.TraceEventType.Information, "title", null); result.Log(entry); mockedLogWriter.AssertWasCalled(lw => lw.Write(Arg.Is(entry))); }
public void EntLib5UseCase() { // construct the Configuration Source to use var builder = new ConfigurationSourceBuilder(); // fluent API configuration builder.ConfigureLogging() .WithOptions .DoNotRevertImpersonation() .LogToCategoryNamed("Simple") .SendTo.FlatFile("Simple Log File") .FormatWith(new FormatterBuilder() .TextFormatterNamed("simpleFormat") .UsingTemplate("{timestamp} : {message}{newline}")) .ToFile("simple.log"); var configSource = new DictionaryConfigurationSource(); builder.UpdateConfigurationWithReplace(configSource); EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(configSource); ILog log = LogManager.GetLogger(GetType()); log.Debug("Debug Event Log Entry."); log.Warn("Warning Event Log Entry."); }
public void ConfigurationChangeNotificationRefreshesLoggerAutomatically() { using (var configurationSource = new SystemConfigurationSource(true, 100)) using (var serviceLocator = (UnityServiceLocator)EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource)) { EnterpriseLibraryContainer.Current = serviceLocator; Logger.Reset(); MockTraceListener.Reset(); Logger.Write("test", "MockCategoryOne"); Assert.AreEqual(1, MockTraceListener.Entries.Count); System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); LoggingSettings rwSettings = rwConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings; ((CategoryFilterData)rwSettings.LogFilters.Get("Category")).CategoryFilters.Add(new CategoryFilterEntry("MockCategoryOne")); rwConfiguration.Save(); Thread.Sleep(1000); MockTraceListener.Reset(); Logger.Write("test", "MockCategoryOne"); Assert.AreEqual(0, MockTraceListener.Entries.Count); } }
private void ConfigureLogging() { var configurationSource = new DictionaryConfigurationSource(); var builder = new ConfigurationSourceBuilder(); const string DefaultListenerName = "Default"; builder.ConfigureLogging() .WithOptions .DoNotRevertImpersonation() .SpecialSources .LoggingErrorsAndWarningsCategory .SendTo.SharedListenerNamed(DefaultListenerName) .SpecialSources .UnprocessedCategory .SendTo.SharedListenerNamed(DefaultListenerName) .SpecialSources .AllEventsCategory .SendTo.SharedListenerNamed(DefaultListenerName) .LogToCategoryNamed("General") .WithOptions.SetAsDefaultCategory() .SendTo.SharedListenerNamed(DefaultListenerName); builder.UpdateConfigurationWithReplace(configurationSource); var configurator = new UnityContainerConfigurator(this.Container); EnterpriseLibraryContainer.ConfigureContainer(configurator, configurationSource); this.Container.RegisterType <TraceListener, CommonLoggingEntlibTraceListener>( DefaultListenerName, new ContainerControlledLifetimeManager(), new InjectionFactory(this.CreateListener)); }
public void AddingCategoryFilterToConfigIsReflectedInContainer() { using (var configurationSource = new SystemConfigurationSource(false)) using (var serviceLocator = (UnityServiceLocator)EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource)) { EnterpriseLibraryContainer.Current = serviceLocator; Logger.Reset(); MockTraceListener.Reset(); Logger.Write("test", "MockCategoryOne"); Assert.AreEqual(1, MockTraceListener.Entries.Count); System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); LoggingSettings rwSettings = rwConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings; ((CategoryFilterData)rwSettings.LogFilters.Get("Category")).CategoryFilters.Add(new CategoryFilterEntry("MockCategoryOne")); rwConfiguration.Save(); ((IConfigurationSourceTest)configurationSource).ConfigSourceChanged(string.Empty); var categoryFilter = EnterpriseLibraryContainer.Current.GetInstance <CategoryFilter>("Category"); Assert.AreEqual(1, categoryFilter.CategoryFilters.Count(c => c == "MockCategoryOne")); } }
public void ConfigurationChangeNotificationRefreshesLogger() { using (var configurationSource = new SystemConfigurationSource(false)) using (var serviceLocator = (UnityServiceLocator)EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource)) { EnterpriseLibraryContainer.Current = serviceLocator; Logger.Reset(); MockTraceListener.Reset(); Logger.Write("test", "MockCategoryOne"); Assert.AreEqual(1, MockTraceListener.Entries.Count); System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); LoggingSettings rwSettings = rwConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings; ((CategoryFilterData)rwSettings.LogFilters.Get("Category")).CategoryFilters.Add(new CategoryFilterEntry("MockCategoryOne")); rwConfiguration.Save(); ((IConfigurationSourceTest)configurationSource).ConfigSourceChanged(string.Empty); MockTraceListener.Reset(); Logger.Write("test", "MockCategoryOne"); Assert.AreEqual(0, MockTraceListener.Entries.Count, "should have been filtered out by the new category filter"); } }
public override void createTestFixture() { base.createTestFixture(); ObjectsConverter.Configure(); configureLogging(); clientInformation = new ClientInformation() { Version = Const.ServiceVersion }; clientInformation.ApplicationLanguage = "en"; clientInformation.PlatformVersion = "fgfdgdfg"; clientInformation.ApplicationVersion = "1.0.0.0"; var conf = new ConfigurationSourceBuilder(); conf.ConfigureCaching().ForCacheManagerNamed(SecurityManager.AuthenticationCacheName).StoreInMemory(); var configSource = new DictionaryConfigurationSource(); conf.UpdateConfigurationWithReplace(configSource); var xmlStream = DateTimeExtension.GetResource("BodyArchitect.UnitTests.V2.BAPointsTests.BAPoints.xml"); var paymentsManager = new PaymentsManager(); this.paymentsManager = paymentsManager.Load(xmlStream); InternalBodyArchitectService.PaymentsManager = this.paymentsManager; EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(configSource); }
public void EntLib5FactoryTestWithFluentConfig() { // construct the Configuration Source to use var builder = new ConfigurationSourceBuilder(); // fluent API configuration builder.ConfigureLogging() .WithOptions .DoNotRevertImpersonation() .LogToCategoryNamed("Simple") .SendTo.FlatFile("Simple Log File") .FormatWith(new FormatterBuilder() .TextFormatterNamed("simpleFormat") .UsingTemplate("{timestamp} : {message}{newline}")) .ToFile("simple.log"); var configSource = new DictionaryConfigurationSource(); builder.UpdateConfigurationWithReplace(configSource); EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(configSource); // initialize the EntLib5 Logger factory with configuration file EntLib5Factory factory = new EntLib5Factory(); ILog log = factory.GetLogger(GetType()); Assert.IsNotNull(log); Assert.IsNotNull(log as EntLib5Logger); }
public void TestGetExceptionManagerFromServiceLocator() { // Create the container var container = new UnityContainer(); // Configurator will read Enterprise Library configuration // and set up the container var configurator = new UnityContainerConfigurator(container); // Configuration source holds the new configuration we want to use // load this in your own code var configSource = new FileConfigurationSource("EntLib.config.xml"); // Configure the container EnterpriseLibraryContainer.CreateDefaultContainer(configSource); // Wrap in ServiceLocator var locator = new UnityServiceLocator(container); // And set Enterprise Library to use it EnterpriseLibraryContainer.Current = locator; var exceptionManager = EnterpriseLibraryContainer.Current.GetInstance <ExceptionManager>(); Assert.NotNull(exceptionManager); }
private void configureEntLib() { var formatterStandard = new FormatterBuilder().TextFormatterNamed("Text Formatter").UsingTemplate( "Timestamp: {timestamp}{newline}Message: {message}{newline}Severity: {severity}{newline}Machine: {machine}{newline}Process Name: {processName}{newline}Extended Properties: {dictionary({key} - {value}{newline})}"); var conf = new ConfigurationSourceBuilder(); var logConfig = conf.ConfigureLogging(); logConfig.WithOptions.LogToCategoryNamed("Exception").SendTo.RollingFile( "ExceptionFileListener").WithHeader("----------------------------------------").WithFooter("----------------------------------------").ToFile(UserContext.Settings.ExceptionsLogFile); logConfig.WithOptions.LogToCategoryNamed("General").SendTo.RollingFile( "FlatFile TraceListener").WithHeader("----------------------------------------").WithFooter("----------------------------------------").FormatWith(formatterStandard).ToFile(UserContext.Settings.StandardLogFile); logConfig.WithOptions.LogToCategoryNamed("email").SendTo.Email("email").FormatWith(formatterStandard).UsingSmtpServer( ApplicationSettings.MailSmtp).WithUserNameAndPassword(ApplicationSettings.MailUserName, ApplicationSettings.MailPassword).To( ApplicationSettings.MailAccount).From( ApplicationSettings.MailAccount).UseSSL(true); //configure cache var cacheCfg = conf.ConfigureCaching(); cacheCfg.ForCacheManagerNamed(PicturesCache.PicturesCacheName).StoreInIsolatedStorage( "Isolated Storage Cache Store").UsePartition("PicturesCache1"); cacheCfg.ForCacheManagerNamed("ErrorCache").StoreInMemory(); var configSource = new DictionaryConfigurationSource(); conf.UpdateConfigurationWithReplace(configSource); EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(configSource); BodyArchitect.Logger.Log.EnableExceptionLog = Settings1.Default.LogErrorEnabled; BodyArchitect.Logger.Log.EnableStandardLog = Settings1.Default.LogStandardEnabled; }
// http://www.nikosbaxevanis.com/bonus-bits/2011/08/following-the-composition-root-pattern-with-enterprise-library.html public static void ForEnterpriseLibrary(UnityContainer container) { var configurator = new UnityContainerConfigurator(container); var configSource = ConfigurationSourceFactory.Create(); EnterpriseLibraryContainer.ConfigureContainer(configurator, configSource); }
public void Setup() { container = new UnityContainer(); var configurationSource = new SystemConfigurationSource(); EnterpriseLibraryContainer.ConfigureContainer(new UnityContainerConfigurator(container), configurationSource); }
/// <summary> /// Initializes a new instance of the <see cref="EntLib5Factory"/> class. /// </summary> /// <param name="EntLib5ConfigurationSrc">The enterprise library 5.0 configuration source to load. Supercedes any configuration found in the Config file.</param> public EntLib5Factory(IConfigurationSource EntLib5ConfigurationSrc) { // replace any settings from App.Config with the ones in the provided config source var builder = new ConfigurationSourceBuilder(); builder.UpdateConfigurationWithReplace(EntLib5ConfigurationSrc); EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(EntLib5ConfigurationSrc); }
private static TraceListener GetListener(string name, IConfigurationSource configurationSource) { var container = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource); var listener = container.GetInstance <TraceListener>(name); container.Dispose(); return(listener); }
public void CanResolveCryptoProvider() { IServiceLocator container = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource); ISymmetricCryptoProvider provider = container.GetInstance <ISymmetricCryptoProvider>(symmetricInstance); Assert.IsNotNull(provider); Assert.AreSame(typeof(DpapiSymmetricCryptoProvider), provider.GetType()); }
public InterceptionStrategy() { IUnityContainer container = new UnityContainer(); UnityContainerConfigurator configurator = new UnityContainerConfigurator(container); EnterpriseLibraryContainer.ConfigureContainer(configurator, ConfigurationSourceFactory.Create()); this.UnityContainer = container; this.InterceptionMember = new InstanceInterceptionPolicySettingInjectionMember(new TransparentProxyInterceptor()); }
public void CanBuildLogWriterStructureHolder() { LogWriterStructureHolder setup = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource) .GetInstance <LogWriterStructureHolder>(); Assert.IsNotNull(setup); Assert.AreEqual(2, setup.TraceSources.Count); }
public void StaticFacadeUsesTheCurrentServiceLocator() { GlobalCountCallHandler.Calls.Clear(); var interceptionConfigurationSource = new DictionaryConfigurationSource(); interceptionConfigurationSource.Add( PolicyInjectionSettings.SectionName, new PolicyInjectionSettings { Policies = { new PolicyData("policy") { MatchingRules = { new CustomMatchingRuleData("always", typeof(AlwaysMatchingRule)) }, Handlers = { new CustomCallHandlerData("count", typeof(GlobalCountCallHandler)) { Attributes ={ { "callhandler","count" } } } } } } }); var interceptionLocator = EnterpriseLibraryContainer.CreateDefaultContainer(interceptionConfigurationSource); var noInterceptionLocator = EnterpriseLibraryContainer.CreateDefaultContainer(new DictionaryConfigurationSource()); try { EnterpriseLibraryContainer.Current = interceptionLocator; var interceptedWrappable = PolicyInjection.Create <Wrappable>(); interceptedWrappable.Method(); Assert.AreEqual(1, GlobalCountCallHandler.Calls.Count); GlobalCountCallHandler.Calls.Clear(); EnterpriseLibraryContainer.Current = noInterceptionLocator; var nonInterceptedWrappable = PolicyInjection.Create <Wrappable>(); nonInterceptedWrappable.Method(); Assert.AreEqual(0, GlobalCountCallHandler.Calls.Count); } finally { EnterpriseLibraryContainer.Current = null; GlobalCountCallHandler.Calls.Clear(); interceptionLocator.Dispose(); noInterceptionLocator.Dispose(); } }
/// <summary> /// Configures the Unity container to be able to resolve Enterprise Library /// objects. /// </summary> protected override void Initialize() { // Only need to do this once; do nothing if this extension has already // been added. if (Container.Configure <EnterpriseLibraryCoreExtension>() == this) { var configurator = new UnityContainerConfigurator(Container); EnterpriseLibraryContainer.ConfigureContainer(configurator, configurationSource); } }
protected override void Act() { IServiceLocator locator = EnterpriseLibraryContainer.CreateDefaultContainer(GetConfig()); EnterpriseLibraryContainer.Current = locator; staticFu = EnterpriseLibraryContainer.Current.GetInstance <StaticFu>(); Assert.IsInstanceOfType(staticFu.MyInnerFoo, typeof(Foo)); updatableConfigSource.DoSourceChanged(new[] { "MockRegistrationProvider" }); }
static IServiceLocator GetContainerWithTracingFlag(bool tracingEnabled) { var config = new FileConfigurationSource(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, false); var loggingSettings = ((LoggingSettings)config.GetSection(LoggingSettings.SectionName)); loggingSettings.TracingEnabled = tracingEnabled; Logger.Reset(); return(EnterpriseLibraryContainer.CreateDefaultContainer(config)); }
public static void SetCurrentLocator(IServiceLocator locator) { var newContainer = new EnterpriseLibraryContainer(locator); lock (globalContainerLock) { globalContainer = newContainer; } }
public void Given() { context = new MockLocatorContext(); container = new EnterpriseLibraryContainer(context.MockLocator); }