private static void SetupMockedContainerForVerificationTests(Mock <IUnityContainer> mockedContainer)
{
var mockedModuleInitializer = new Mock <IModuleInitializer>();
var mockedModuleManager = new Mock <IModuleManager>();
var regionAdapterMappings = new RegionAdapterMappings();
var containerExtension = new UnityContainerExtension(mockedContainer.Object);
var regionBehaviorFactory = new RegionBehaviorFactory(containerExtension);
mockedContainer.Setup(c => c.RegisterInstance(It.IsAny <Type>(), It.IsAny <string>(), It.IsAny <object>(), It.IsAny <IInstanceLifetimeManager>()));
mockedContainer.Setup(c => c.Resolve(typeof(IModuleCatalog), (string)null)).Returns(
new ModuleCatalog());
mockedContainer.Setup(c => c.Resolve(typeof(IModuleInitializer), (string)null)).Returns(
mockedModuleInitializer.Object);
mockedContainer.Setup(c => c.Resolve(typeof(IModuleManager), (string)null)).Returns(
mockedModuleManager.Object);
mockedContainer.Setup(c => c.Resolve(typeof(RegionAdapterMappings), (string)null)).Returns(
regionAdapterMappings);
mockedContainer.Setup(c => c.Resolve(typeof(SelectorRegionAdapter), (string)null)).Returns(
new SelectorRegionAdapter(regionBehaviorFactory));
mockedContainer.Setup(c => c.Resolve(typeof(ItemsControlRegionAdapter), (string)null)).Returns(
new ItemsControlRegionAdapter(regionBehaviorFactory));
mockedContainer.Setup(c => c.Resolve(typeof(ContentControlRegionAdapter), (string)null)).Returns(
new ContentControlRegionAdapter(regionBehaviorFactory));
}
public static IAutoRegistration ConfigureSelfAutoRegistration(this UnityContainerExtension parent)
{
Contract.Assert(parent != null);
Contract.Assert(parent.Container != null);
return(parent.Container.ConfigureSelfAutoRegistration(parent.GetType()));
}
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 void AddExtension(UnityContainerExtension extensionModule)
{
if (extensionModule != null)
{
_container.AddExtension(extensionModule);
}
}
protected override IContainerExtension CreateContainerExtension()
{
var unity = new UnityContainer().AddExtension(new Diagnostic());
var container = new UnityContainerExtension(unity);
var mainScope = new ScopedContainer(container, unity);
container.RegisterInstance <IScopedContainer>(mainScope);
return(container);
}
public static void InitServices(UnityContainerExtension initialization)
{
var container = new UnityContainer();
var configSource = ConfigurationSourceFactory.Create();
container.RegisterType <IConfigurationSource>(new InjectionFactory(c => configSource));
container.AddExtension(initialization);
ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(container));
}
public static void WellKnownITypeNameAutoRegistration <T>(this UnityContainerExtension parent, string value)
where T : LifetimeManager, new()
{
Contract.Assert(parent != null);
parent
.ConfigureSelfAutoRegistration()
.IncludeWellKnownITypeName <T>(value)
.ApplyAutoRegistration();
}
public IScopedContainer CreateScope()
{
var childContainer = unity.CreateChildContainer();
var extensions = new UnityContainerExtension(childContainer);
var scope = new ScopedContainer(extensions, childContainer);
extensions.RegisterInstance <IScopedContainer>(scope);
extensions.RegisterInstance <IContainerExtension>(scope);
extensions.RegisterInstance <IContainerProvider>(scope);
extensions.RegisterInstance <IContainerRegistry>(scope);
return(scope);
}
public static IAutoRegistration ConfigureSelfAutoRegistration(this UnityContainerExtension parent, params Type[] types)
{
Contract.Assert(parent != null);
Contract.Assert(parent.Container != null);
var list = new List <Type>(types)
{
parent.GetType()
};
return(parent.Container.ConfigureSelfAutoRegistration(list.ToArray()));
}
protected override IContainerExtension CreateContainerExtension()
{
IUnityContainer unity = new UnityContainer();
#if DEBUG
unity = unity.AddExtension(new Diagnostic());
#endif
var container = new UnityContainerExtension(unity);
var mainScope = new ScopedContainer(container, unity);
container.RegisterInstance <IScopedContainer>(mainScope);
ViewBind.ContainerProvider = container;
return(container);
}
public static void Start(UnityContainerExtension initialization = null)
{
if (!isInitialized)
{
lock (LockObject)
{
if (!isInitialized)
{
ConfigureUnity(initialization);
isInitialized = true;
}
}
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
//TODO: move to IStartupTask implementation(s)
UnityContainerExtension containerExtension = new UnityContainerExtension();
Bootstrapper.With.Container(containerExtension).Start();
IControllerFactory controllerFactory = new UnityControllerFactory(ContainerManager.Container);
ControllerBuilder.Current.SetControllerFactory(controllerFactory);
}
public void ShouldForwardResolveToInnerContainer()
{
object myInstance = new object();
var mockContainer = new Mock <IUnityContainer>();
mockContainer.Setup(c => c.Resolve(typeof(object), null, It.IsAny <ResolverOverride[]>())).Returns(myInstance);
var containerExtension = new UnityContainerExtension(mockContainer.Object);
ContainerLocator.ResetContainer();
ContainerLocator.SetContainerExtension(() => containerExtension);
var resolved = ContainerLocator.Container.Resolve(typeof(object));
mockContainer.Verify(c => c.Resolve(typeof(object), null, It.IsAny <ResolverOverride[]>()), Times.Once);
Assert.Same(myInstance, resolved);
}
/// <summary>
/// Initializes the unity container.
/// </summary>
/// <param name="containerName">Name of the container.</param>
/// <param name="unityContainerExtension">Optionally, a unity container extension you might want to register</param>
/// <returns>Unity container.</returns>
public static IUnityContainer InitializeContainer(string containerName, UnityContainerExtension unityContainerExtension = null)
{
if (Container == null)
{
Container = new UnityContainer();
if (unityContainerExtension != null)
{
Container.AddExtension(unityContainerExtension);
}
}
UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection(UnityConfigurationSection.SectionName);
section.Configure(Container, containerName);
return(Container);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
//TODO: move to IStartupTask implementation(s)
UnityContainerExtension containerExtension = new UnityContainerExtension();
Bootstrapper.With.Container(containerExtension).Start();
IControllerFactory controllerFactory = new UnityControllerFactory(ContainerManager.Container);
ControllerBuilder.Current.SetControllerFactory(controllerFactory);
string autoUpdatePath = HttpContext.Current.Server.MapPath("~/App_Data/AutoUpdate");
DirectoryInfo autoUpdateDirectory = new DirectoryInfo(autoUpdatePath);
if (!autoUpdateDirectory.Exists)
{
autoUpdateDirectory.Create();
}
}
static async Task Main(string[] args)
{
var container = new UnityContainerExtension();
DependencyInjectionContainer.Initialize(container);
try
{
//await ImageryFileTest.RunTest(container);
//await DisplayFileTest.RunTest(container);
var testAccess = container.Resolve <IAccessDeviceDailyStatistics>();
testAccess.UpdateDeviceDailyStatistics();
//await engine.ConsumeAsync(message, CancellationToken.None);
}
catch (Exception e)
{
Console.WriteLine("OOPS!!");
Console.WriteLine();
Console.WriteLine(e);
Console.WriteLine();
Console.WriteLine("Press 'Enter' to exit.");
}
}
public IUnityContainer AddExtension(UnityContainerExtension extension)
{
return(this);
}
public IUnityContainer AddExtension(UnityContainerExtension extension)
{
ConfigActions.Add(ConfigurationActionRecord.AddExtensionAction(extension.GetType()));
return(this);
}
// ReSharper disable once UnusedMember.Global
public static IUnityContainer AddExtension(UnityContainerExtension extension)
{
return(Container.AddExtension(extension));
}
IUnityContainer IUnityContainer.AddExtension(UnityContainerExtension extension)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Add an extension object to the container.
/// </summary>
/// <param name="extension">UnityContainerExtension to add.</param>
public void AddUnityExtension(UnityContainerExtension extension)
{
_container.AddExtension(extension);
}
protected override IContainerExtension CreateContainerExtension()
{
UnityContainerExtension unityContainerExtension = new UnityContainerExtension(_explorerBootstrapper.CreateContainer());
return(unityContainerExtension);
}
/// <summary>
/// Add a new extension to the given <paramref name="container"/>, only
/// if the extension hasn't already been added to the container.
/// </summary>
/// <param name="container">The container to add the extension to.</param>
/// <param name="extension">The extension object.</param>
/// <returns><paramref name="container"/></returns>
public static IUnityContainer AddExtensionIfNotPresent(this IUnityContainer container, UnityContainerExtension extension)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
if (extension == null)
{
throw new ArgumentNullException("extension");
}
Type extensionType = extension.GetType();
if (container.Configure(extensionType) == null)
{
container.AddExtension(extension);
}
return(container);
}
/// <summary>
/// Add an extension object to the container.
/// </summary>
/// <param name="extension">
/// <see cref="T:Microsoft.Practices.Unity.UnityContainerExtension"/> to add.
/// </param>
/// <returns>
/// The <see cref="T:Microsoft.Practices.Unity.UnityContainer"/> object that this method was called on (this in C#, Me
/// in Visual Basic).
/// </returns>
public IUnityContainer AddExtension(UnityContainerExtension extension)
{
return(this.RootContainer.AddExtension(extension));
}
/// <summary>
/// Applies <c>UnityContainerExtension</c> to inner <c>IUnityContainer</c>.
/// </summary>
/// <param name="extension">Container extension to apply.</param>
public static void ApplyContainerExtension(UnityContainerExtension extension)
{
Container.AddExtension(extension);
}
public IUnityContainer AddExtension(UnityContainerExtension extension)
{
return(_innerContainer.AddExtension(extension));
}
public static async Task RunTest(UnityContainerExtension container)
{
var message = GetMessage();
await container.Resolve <Trimble.Ag.MessageConsumers.FileProcessing.DisplayFileReceivedMessageConsumer>().ConsumeAsync(message, CancellationToken.None);
}
protected void Application_Start(object sender, EventArgs e)
{
UnityContainerExtension containerExtension = new UnityContainerExtension();
Bootstrapper.With.Container(containerExtension).Start();
}
public IUnityContainer AddExtension(UnityContainerExtension extension)
{
throw new NotImplementedException();
}
public IUnityContainer AddExtension(UnityContainerExtension extension)
{
return(decorated.AddExtension(extension));
}
