private static IRpnCalculator GetRpnCalculator()
{
IUnityContainer unityContainer = new UnityContainer();
unityContainer.AddExtension(new StackUnityContainerExtension());
unityContainer.AddExtension(new RpnCalculatorUnityContainerExtension());
return(unityContainer.Resolve <IRpnCalculator>());
}
public void AddExtensionTest()
{
// Act
container.AddExtension(mock)
.AddExtension(other)
.AddExtension(derived);
// Validate
Assert.IsTrue(mock.InitializeWasCalled);
Assert.IsTrue(other.InitializeWasCalled);
Assert.IsTrue(derived.InitializeWasCalled);
}
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>();
container.AddExtension(new DataUnityContainerExtension());
container.AddExtension(new APIUnityContainerExtension());
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
}
public void CreatedPoliciesIncludeContainerLifetime()
{
TraceListenerData listenerData = new MockTraceListenerData("listener");
loggingSettings.TraceListeners.Add(listenerData);
MockTraceListener listener = null;
using (IUnityContainer newContainer = new UnityContainer())
{
newContainer.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource));
listener =
(MockTraceListener)((ReconfigurableTraceListenerWrapper)newContainer.Resolve <TraceListener>("listener")).InnerTraceListener;
Assert.IsNotNull(listener);
Assert.AreSame(
listener,
((ReconfigurableTraceListenerWrapper)newContainer.Resolve <TraceListener>("listener")).InnerTraceListener); // lifetime managed?
Assert.IsFalse(listener.wasDisposed);
}
Assert.IsTrue(listener.wasDisposed); // lifetime managed by the container?
}
private static IStack <int> GetStack()
{
IUnityContainer container = new UnityContainer();
container.AddExtension(new StackUnityContainerExtension());
return(container.Resolve <IStack <int> >());
}
public void Test1()
{
var container = new UnityContainer();
container.AddExtension(new AOPExtension());
Assert.Pass();
}
static void Main(string[] args)
{
// Create and configure LoggerFactory
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(
new ConsoleLoggerProvider((text, logLevel) => logLevel >= LogLevel.Debug, false));
// Create local logger
ILogger logger = loggerFactory.CreateLogger <Program>();
// Get the container
var container = new UnityContainer();
logger.LogInformation("Created Container");
// Register extension and pass it configured factory
container.AddExtension(new LoggingExtension(loggerFactory));
logger.LogInformation("Added Log4Net Extension");
// Register few types
container.RegisterType <IService, Service>();
logger.LogInformation("Registered few types");
var service = container.Resolve <IService>();
logger.LogInformation("Press any key to continue...");
Console.ReadKey();
}
public DimensionalClearanceService()
{
InitializeComponent();
ExceptionHandlingManager.InitializeExceptionManager();
_container.AddExtension(new ModelContainerExtension());
}
static void Main(string[] args)
{
// 這裡將會建立 DI 容器
IUnityContainer container = new UnityContainer();
var fooInterception = new Interception();
container.AddExtension(fooInterception);
// 進行抽象型別與具體實作類別的註冊
// 在進行註冊抽象與具體實作類別的時候，我們需要進行攔截行為的設定，告知要啟用 Unity 攔截功能
container.RegisterType <IMessage, ConsoleMessage>(
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <AppLog>(),
new InterceptionBehavior <VirtualLog>());
// 進行抽象型別的具體實作物件的解析
IMessage message = container.Resolve <IMessage>();
Console.WriteLine($"{Environment.NewLine}呼叫 IMessage.Write");
// 執行取得物件的方法
message.Write("Hi Vulcan");
Console.WriteLine($"{Environment.NewLine}呼叫 IMessage.Empty");
message.Empty();
Console.WriteLine("Press any key for continuing...");
Console.ReadKey();
}
public void CreatesAppropriatePoliciesIfProviderHasProperConstructor()
{
TestCustomProviderData data = new TestCustomProviderData();
data.Name = "name";
data.Type = typeof(TestCustomProviderWithValidConstructor);
data.Attributes = new NameValueCollection();
data.Attributes["name1"] = "value1";
data.Attributes["name2"] = "value2";
CustomProviderPolicyCreator <TestCustomProviderData> policyCreator
= new CustomProviderPolicyCreator <TestCustomProviderData>();
TestHelperExtension extension = new TestHelperExtension();
extension.initialize = context =>
{
((IContainerPolicyCreator)policyCreator).CreatePolicies(context.Policies, data.Name, data, null);
};
IUnityContainer container = new UnityContainer();
container.AddExtension(extension);
TestCustomProviderWithValidConstructor createdObject
= container.Resolve <TestCustomProviderWithValidConstructor>("name");
Assert.IsNotNull(createdObject);
Assert.AreEqual(2, createdObject.Attributes.Count);
Assert.AreEqual("value1", createdObject.Attributes["name1"]);
Assert.AreEqual("value2", createdObject.Attributes["name2"]);
}
private static void ConfigureUnity(UnityContainerExtension initialization)
{
Logger.InfoFormat("Starting the server [{0}]", typeof(Shell).Assembly.EffectiveVersion());
try
{
var configurationSource = ConfigurationSourceFactory.Create();
var container = new UnityContainer()
.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource))
.RegisterInstance(configurationSource);
var serviceLocator = new UnityServiceLocator(container);
Microsoft.Practices.ServiceLocation.ServiceLocator.SetLocatorProvider(() => serviceLocator);
EnterpriseLibraryContainer.Current = serviceLocator;
if (initialization != null)
{
container.AddExtension(initialization);
}
var section = (UnityConfigurationSection)configurationSource.GetSection("unity");
if (section != null)
{
section.Configure(container);
}
}
catch (Exception ex)
{
Logger.Fatal("Unexpected error while container initialization", ex);
throw;
}
}
public static void Start()
{
string configurationFilepath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Quartz.config");
var configurationFileMap = new ExeConfigurationFileMap {
ExeConfigFilename = configurationFilepath
};
var configuration = ConfigurationManager.OpenMappedExeConfiguration(configurationFileMap, ConfigurationUserLevel.None);
System.Xml.XmlDocument sectionXmlDocument = new System.Xml.XmlDocument();
sectionXmlDocument.Load(new StringReader(configuration.GetSection("quartz").SectionInformation.GetRawXml()));
NameValueSectionHandler handler = new NameValueSectionHandler();
var quartzProperties = (NameValueCollection)handler.Create(null, null, sectionXmlDocument.DocumentElement);
LogProvider.SetCurrentLogProvider(new Areas.CmsAdmin.Scheduler.EntLibLogProvider());
var logEntiry = new Microsoft.Practices.EnterpriseLibrary.Logging.LogEntry();
logEntiry.Title = "Scheduler Event";
logEntiry.Severity = System.Diagnostics.TraceEventType.Start;
logEntiry.Message = "Restart the scheduler has been completed";
Microsoft.Practices.EnterpriseLibrary.Logging.Logger.Write(logEntiry);
IUnityContainer unityContainer = new UnityContainer();
ConfigUnityContainer(unityContainer);
unityContainer.AddExtension(new QuartzUnityExtension(quartzProperties));
unityContainer.Resolve <IScheduler>().Start();
}
public static IUnityContainer InitialiseContainer()
{
var unityContainer = new UnityContainer();
unityContainer.AddExtension(new ScheduleFeedFileDependencies());
return(unityContainer);
}
public void UnityCanResolveEnumerableOfLazyTypesRegisteredInUnityTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Add composition support for unity
unityContainer.AddExtension(new CompositionIntegration(true));
unityContainer.Configure <CompositionIntegration>().Catalogs.Add(assemblyCatalog);
UnityComponent1.InstanceCount = 0;
unityContainer.RegisterType <IUnityComponent, UnityComponent1>();
unityContainer.RegisterType <IUnityComponent, UnityComponent2>("component2");
var collectionOfLazyUnityComponents = unityContainer.Resolve <IEnumerable <Lazy <IUnityComponent> > >();
Assert.That(collectionOfLazyUnityComponents, Is.Not.Null);
Assert.That(UnityComponent1.InstanceCount, Is.EqualTo(0));
var list = new List <Lazy <IUnityComponent> >(collectionOfLazyUnityComponents);
Assert.That(UnityComponent1.InstanceCount, Is.EqualTo(0));
Assert.That(list[0].Value, Is.Not.Null);
Assert.That(list[1].Value, Is.Not.Null);
Assert.That(UnityComponent1.InstanceCount, Is.EqualTo(1));
Assert.That(list.Count, Is.EqualTo(2));
}
public void UnityCanResolveEnumerableOfLazyTypeRegisteredInMefWithStronglyTypedMetadataTest()
{
//throw new NotImplementedException();
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Add composition support for unity
unityContainer.AddExtension(new CompositionIntegration(false));
unityContainer.Configure <CompositionIntegration>().Catalogs.Add(assemblyCatalog);
var lazyMefComponent = unityContainer.Resolve <IEnumerable <Lazy <IPartWithStronglyTypedMetadata, IMyStronglyTypedMetadataAttribute> > >().ToArray();
Assert.That(lazyMefComponent, Is.Not.Null);
Assert.That(lazyMefComponent[0].Value, Is.Not.Null);
Assert.That(lazyMefComponent[0].Metadata, Is.Not.Null);
Assert.That(lazyMefComponent[0].Value.GetType(), Is.EqualTo(typeof(StronglyTypedHelloWorldDispatcher)));
}
protected override ServiceHost CreateServiceHost(
Type serviceType, Uri[] baseAddresses)
{
UnityServiceHost serviceHost = new UnityServiceHost(serviceType, baseAddresses);
UnityContainer container = new UnityContainer();
container.EnableDebugDiagnostic();
container.EnableDiagnostic();
container.AddExtension(new Diagnostic());
serviceHost.Container = container;
//configure container
UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
section.Configure(container);
//section.Containers.Default.Configure(serviceHost.Container);
return(serviceHost);
}
public void UnityCanResolveLazyTypeRegisteredInMefWithoutItsMetadataTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Add composition support for unity
unityContainer.AddExtension(new CompositionIntegration(false));
unityContainer.Configure <CompositionIntegration>().Catalogs.Add(assemblyCatalog);
var lazyMefComponent = unityContainer.Resolve <Lazy <IPartWithTextMetadata> >();
Assert.That(lazyMefComponent, Is.Not.Null);
Assert.That(lazyMefComponent.Value, Is.Not.Null);
Assert.That(lazyMefComponent, Is.Not.Null);
}
public void ResolverWithElementsReturnsLiteralElements()
{
IUnityContainer container = new UnityContainer();
object o1 = new object();
object o2 = new object();
object o3 = new object();
container
.RegisterInstance <object>("o1", o1)
.RegisterInstance <object>("o2", o2);
ResolvedArrayWithElementsResolverPolicy resolver
= new ResolvedArrayWithElementsResolverPolicy(
typeof(object),
new LiteralValueDependencyResolverPolicy(o1),
new LiteralValueDependencyResolverPolicy(o3));
container.AddExtension(new InjectedObjectConfigurationExtension(resolver));
object[] results = (object[])container.Resolve <InjectedObject>().injectedValue;
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Length);
Assert.AreSame(o1, results[0]);
Assert.AreSame(o3, results[1]);
}
public void UnityCanResolveEnumerableOfTypesRegisteredInUnityAndMefTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
MixedComponent1.InstanceCount = 0;
MixedComponent2.InstanceCount = 0;
MixedComponent5.InstanceCount = 0;
// Add composition support for unity
unityContainer.AddExtension(new CompositionIntegration(true));
unityContainer.Configure <CompositionIntegration>().Catalogs.Add(assemblyCatalog);
unityContainer.RegisterType <IMixedComponent, MixedComponent1>("component1");
unityContainer.RegisterType <IMixedComponent, MixedComponent2>("component2");
unityContainer.RegisterType <IMixedComponent, MixedComponent3>();
var collectionOfLazyUnityComponents = unityContainer.Resolve <IEnumerable <IMixedComponent> >();
Assert.That(collectionOfLazyUnityComponents, Is.Not.Null);
Assert.That(MixedComponent1.InstanceCount, Is.EqualTo(1));
Assert.That(MixedComponent2.InstanceCount, Is.EqualTo(1));
Assert.That(MixedComponent5.InstanceCount, Is.EqualTo(1));
var list = new List <IMixedComponent>(collectionOfLazyUnityComponents);
Assert.That(list.Count, Is.EqualTo(5));
Assert.That(list.OfType <MixedComponent1>().Count(), Is.EqualTo(1));
Assert.That(list.OfType <MixedComponent2>().Count(), Is.EqualTo(1));
Assert.That(list.OfType <MixedComponent3>().Count(), Is.EqualTo(1));
Assert.That(list.OfType <MixedComponent4>().Count(), Is.EqualTo(1));
Assert.That(list.OfType <MixedComponent5>().Count(), Is.EqualTo(1));
}
public static UnityContainer RegisterTypes(UnityContainer container)
{
var mock = new Mock <IHttpContextAccessor>();
container.RegisterInstance(mock.Object);
container.RegisterType <ILoggerFactory, LoggerFactory>(
new ContainerControlledLifetimeManager(), new InjectionConstructor(new ResolvedParameter <IEnumerable <ILoggerProvider> >())
);
container.AddExtension(new Diagnostic());
container.AddNewExtension <LoaderConfigurationExtension>();
container.RegisterType <IContentDefinitionService, ContentDefinitionService>();
container.RegisterType <ISettingsService, SettingsService>();
container.RegisterType <IArticleService, ArticleServiceFake>();
container.RegisterType <IProductService, FakeProductLoader>();
container.RegisterType <IConnectionProvider, ConnectionProviderFake>(new InjectionConstructor("test"));
container.RegisterType <ICacheProvider, CacheProvider>(new ContainerControlledLifetimeManager());
container.RegisterType <VersionedCacheProviderBase>(new ContainerControlledLifetimeManager());
container.RegisterType <IContentInvalidator, DpcContentInvalidator>();
container.RegisterType <IUserProvider, ProductCatalog.Actions.Services.AlwaysAdminUserProvider>();
container.RegisterInstance <ICacheItemWatcher>(new CacheItemWatcherFake());
// логируем в консоль
container.RegisterInstance <ILogger>(new TextWriterLogger(Console.Out));
return(container);
}
public void ContainerControlledLifetimeReturnsSameInstanceFromMultipleThreads()
{
IUnityContainer container = new UnityContainer();
container.AddExtension(new SpyExtension(new DelayStrategy(), UnityBuildStage.Lifetime));
container.RegisterType <object>(new ContainerControlledLifetimeManager());
object result1 = null;
object result2 = null;
Thread thread1 = new Thread(delegate()
{
result1 = container.Resolve <object>();
});
Thread thread2 = new Thread(delegate()
{
result2 = container.Resolve <object>();
});
thread1.Name = "1";
thread2.Name = "2";
thread1.Start();
thread2.Start();
thread2.Join();
thread1.Join();
Assert.IsNotNull(result1);
Assert.AreSame(result1, result2);
}
public void SkipsConnectionStringsWithoutProviderNamesOrWithProviderNamesWhichDoNotMapToAProviderFactory()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
ConnectionStringsSection section = new ConnectionStringsSection();
section.ConnectionStrings.Add(new ConnectionStringSettings("cs1", "cs1", "System.Data.SqlClient"));
section.ConnectionStrings.Add(new ConnectionStringSettings("cs2", "cs2"));
section.ConnectionStrings.Add(new ConnectionStringSettings("cs3", "cs3", "a bogus provider name"));
section.ConnectionStrings.Add(new ConnectionStringSettings("cs4", "cs4", "System.Data.SqlClient"));
configurationSource.Add("connectionStrings", section);
IUnityContainer container = new UnityContainer();
container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource));
container.AddNewExtension <DataAccessBlockExtension>();
Assert.AreEqual("cs1", container.Resolve <Database>("cs1").ConnectionString);
Assert.AreEqual("cs4", container.Resolve <Database>("cs4").ConnectionString);
try
{
container.Resolve <Database>("cs2");
Assert.Fail("should have thrown");
}
catch (ResolutionFailedException)
{
}
try
{
container.Resolve <Database>("cs3");
Assert.Fail("should have thrown");
}
catch (ResolutionFailedException)
{
}
}
static void Main(string[] args)
{
var container = new UnityContainer();
var connectionString = ConfigurationManager.ConnectionStrings["DataBaseConnection"].ConnectionString;
container.AddExtension(new DataContainerExtension <HierarchicalLifetimeManager>(connectionString));
container.RegisterType <IJudgeService, JudgeServiceImplementation>(new HierarchicalLifetimeManager());
var service = container.Resolve <CheckService>();
Console.WriteLine("Press any key to exit...");
while (true)
{
try
{
service.Check();
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(ex);
Console.ResetColor();
}
if (Console.KeyAvailable)
{
break;
}
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
public void ResolverWithElementsReturnsResolvedElementsForBaseClass()
{
IUnityContainer container = new UnityContainer();
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
container
.RegisterInstance <ILogger>("o1", o1)
.RegisterInstance <ILogger>("o2", o2);
ResolvedArrayWithElementsResolverPolicy resolver
= new ResolvedArrayWithElementsResolverPolicy(
typeof(ILogger),
new NamedTypeDependencyResolverPolicy(typeof(ILogger), "o1"),
new NamedTypeDependencyResolverPolicy(typeof(ILogger), "o2"));
container.AddExtension(new InjectedObjectConfigurationExtension(resolver));
ILogger[] results = (ILogger[])container.Resolve <InjectedObject>().injectedValue;
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Length);
Assert.AreSame(o1, results[0]);
Assert.AreSame(o2, results[1]);
}
public void ContainerCallsExtensionsInitializeMethod()
{
MockContainerExtension extension = new MockContainerExtension();
IUnityContainer container = new UnityContainer();
container.AddExtension(extension);
Assert.IsTrue(extension.InitializeWasCalled);
}
/// <summary>
/// Raises the <see cref="E:System.Windows.Application.Startup" /> event.
/// </summary>
/// <param name="e">A <see cref="T:System.Windows.StartupEventArgs" /> that contains the event data.</param>
protected override void OnStartup(StartupEventArgs e)
{
var container = new UnityContainer();
container.AddExtension(new MainModuleContainerConfiguration());
base.OnStartup(e);
}
public void TestInitialize()
{
container = new UnityContainer();
var mock = new MockContainerExtension();
container.AddExtension(mock);
context = ((IMockConfiguration)mock).ExtensionContext;
}
protected override IContainerExtension CreateContainerExtension()
{
// https://stackoverflow.com/a/60890148/9530917
var container = new UnityContainer();
container.AddExtension(new Diagnostic());
return(new UnityContainerExtension(container));
}
private static IUnityContainer CreateContainer()
{
var ass = System.Reflection.Assembly.GetAssembly(typeof(IoCManager));
var uri = new Uri(ass.CodeBase.Substring(0, ass.CodeBase.LastIndexOf("/", StringComparison.Ordinal)));
var path = uri.LocalPath;
var ext = new AssemblyNamingConventionScanExtension(path);
var fullPath = Path.Combine(path, "ioc.config");
var container = new UnityContainer();
if (File.Exists(fullPath))
{
var inp = new FileStream(fullPath, FileMode.Open);
try
{
var root = XElement.Load(inp);
var conventions = root.Elements("NamingConvention");
foreach (var convention in conventions)
{
var type = convention.Attribute("type");
if (type != null)
{
var convType = Type.GetType(type.Value);
if (convType != null)
{
var obj = Activator.CreateInstance(convType);
var conv = obj as NamingConvention;
if (conv != null)
{
var assemblies = convention.Elements("Assembly").Select(asm =>
new Assembly
{
Name = asm.Attribute("name").Value,
FullName = asm.Attribute("fullname").Value
});
conv.Assemblies = assemblies;
ext.RegisterNamingConvention(conv);
}
}
}
}
container.AddExtension(ext);
}
catch (Exception)
{
throw new IoCException("IoC configuration corrupted");
}
finally
{
inp.Close();
}
}
return(container);
}
public void CheckExtensionAddedToContainer()
{
Diagnostic extension = new Diagnostic();
IUnityContainer uc = new UnityContainer();
uc.AddExtension(extension);
Assert.AreSame(uc, extension.Container);
}
public void ContainerCallsExtensionsInitializeMethod()
{
MockContainerExtension extension = new MockContainerExtension();
IUnityContainer container = new UnityContainer();
container.AddExtension(extension);
Assert.True(extension.InitializeWasCalled);
}
public void ExtensionReceivesExtensionContextInInitialize()
{
MockContainerExtension extension = new MockContainerExtension();
IUnityContainer container = new UnityContainer();
container.AddExtension(extension);
Assert.IsNotNull(extension.Context);
Assert.AreSame(container, extension.Context.Container);
}
public void CanLookupExtensionByClassName()
{
MockContainerExtension extension = new MockContainerExtension();
IUnityContainer container = new UnityContainer();
container.AddExtension(extension);
MockContainerExtension result = container.Configure<MockContainerExtension>();
Assert.AreSame(extension, result);
}
public void ResolverWithElementsReturnsResolvedElementsForBaseClass()
{
IUnityContainer container = new UnityContainer();
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
container
.RegisterInstance<ILogger>("o1", o1)
.RegisterInstance<ILogger>("o2", o2);
ResolvedArrayWithElementsResolverPolicy resolver
= new ResolvedArrayWithElementsResolverPolicy(
typeof(ILogger),
new NamedTypeDependencyResolverPolicy(typeof(ILogger), "o1"),
new NamedTypeDependencyResolverPolicy(typeof(ILogger), "o2"));
container.AddExtension(new InjectedObjectConfigurationExtension(resolver));
ILogger[] results = (ILogger[])container.Resolve<InjectedObject>().injectedValue;
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Length);
Assert.AreSame(o1, results[0]);
Assert.AreSame(o2, results[1]);
}
public void ResolverWithElementsReturnsLiteralElements()
{
IUnityContainer container = new UnityContainer();
object o1 = new object();
object o2 = new object();
object o3 = new object();
container
.RegisterInstance<object>("o1", o1)
.RegisterInstance<object>("o2", o2);
ResolvedArrayWithElementsResolverPolicy resolver
= new ResolvedArrayWithElementsResolverPolicy(
typeof(object),
new LiteralValueDependencyResolverPolicy(o1),
new LiteralValueDependencyResolverPolicy(o3));
container.AddExtension(new InjectedObjectConfigurationExtension(resolver));
object[] results = (object[])container.Resolve<InjectedObject>().injectedValue;
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Length);
Assert.AreSame(o1, results[0]);
Assert.AreSame(o3, results[1]);
}
