public void PrepareAndRegisterAndSimpleResolve(IContainerAdapter container)
{
container.PrepareBasic();
container.Resolve(typeof(IBasicService1));
container.Resolve(typeof(ISingleton1));
container.Dispose();
}
public override void MethodToBenchmark(IContainerAdapter container)
{
container.PrepareBasic();
container.Resolve(typeof(IDummyOne));
container.Resolve(typeof(ISingleton1));
container.Dispose();
}
public void SingletonLifetime(IContainerAdapter adapter)
{
adapter.RegisterSingleton<IService, IndependentService>();
var instance1 = adapter.Resolve<IService>();
var instance2 = adapter.Resolve<IService>();
Assert.Same(instance1, instance2);
}
public void TransientLifetime(IContainerAdapter adapter)
{
adapter.RegisterTransient <IService, IndependentService>();
var instance1 = adapter.Resolve <IService>();
var instance2 = adapter.Resolve <IService>();
Assert.NotSame(instance1, instance2);
}
public void SingletonLifetime(IContainerAdapter adapter)
{
adapter.RegisterSingleton <IService, IndependentService>();
var instance1 = adapter.Resolve <IService>();
var instance2 = adapter.Resolve <IService>();
Assert.Same(instance1, instance2);
}
public override void MethodToBenchmark(IContainerAdapter container)
{
var result1 = (ICalculator1)container.Resolve(typeof(ICalculator1));
var result2 = (ICalculator2)container.Resolve(typeof(ICalculator2));
var result3 = (ICalculator3)container.Resolve(typeof(ICalculator3));
result1.Add(5, 10);
result2.Add(5, 10);
result3.Add(5, 10);
}
public void InterceptorToBenchmark(IContainerAdapter container)
{
var result1 = (IInerceptor1)container.Resolve(typeof(IInerceptor1));
var result2 = (IInerceptor2)container.Resolve(typeof(IInerceptor2));
var result3 = (IInerceptor3)container.Resolve(typeof(IInerceptor3));
result1.Concat("Hello", "Wolrd");
result2.Concat("Hello", "Wolrd");
result3.Concat("Hello", "Wolrd");
}
public void RegistrationAtAnyStage(IContainerAdapter adapter)
{
adapter.RegisterType <IService, IndependentService>();
adapter.Resolve <IService>();
adapter.RegisterType <IService2, IndependentService2>();
var resolved = adapter.Resolve <IService2>();
Assert.NotNull(resolved);
}
public override void MethodToBenchmark(IContainerAdapter container)
{
var result1 = (ICalculator1)container.Resolve(typeof(ICalculator1));
var result2 = (ICalculator2)container.Resolve(typeof(ICalculator2));
var result3 = (ICalculator3)container.Resolve(typeof(ICalculator3));
result1.Add(5, 10);
result2.Add(5, 10);
result3.Add(5, 10);
}
/// <summary>
/// Implement this method to configure your application when it starts.
/// For exemple, you can retrieve the view factory from the container,
/// and then retrieve a page and set it as MainPage
/// (you will need a reference to your Application instance).
/// </summary>
/// <param name="container">The dependency container</param>
private void ConfigureApplication(IContainerAdapter container)
{
var viewFactory = container.Resolve <IViewFactory>();
var navigator = container.Resolve <INavigator>();
// Get the first page to show to the user
var detailPage = GetFirstPage(viewFactory);
if (detailPage == null)
{
throw new ArgumentException($"An instance of a Page must be returned in {GetType().FullName}.GetFirstPage()");
}
var detailViewModel = detailPage.BindingContext as IViewModel;
// We might need to use a MasterDetailsPage if this method returns something
var masterPage = GetMasterPage(viewFactory);
IViewModel masterViewModel = null;
if (masterPage != null)
{
masterViewModel = masterPage.BindingContext as IViewModel;
}
// The unit tests cannot go through this block as we don't have an application instance to test
if (App != null)
{
// Navigation events, entering
if (masterViewModel != null)
{
masterViewModel.ViewEntering();
}
if (detailViewModel != null)
{
detailViewModel.ViewEntering();
}
Page navPage = new PillarNavigationPage(detailPage, navigator);
App.MainPage = masterPage == null
? navPage
: new MasterDetailPage {
Master = masterPage, Detail = navPage
};
// Navigation events, entered
if (masterViewModel != null)
{
masterViewModel.ViewEntered();
}
if (detailViewModel != null)
{
detailViewModel.ViewEntered();
}
}
}
public void LazyanBeUsedToResolveCircularDepenendency(IContainerAdapter adapter)
{
adapter.RegisterSingleton <ServiceWithRecursiveLazyDependency1>();
adapter.RegisterSingleton <ServiceWithRecursiveLazyDependency2>();
var resolved1 = adapter.Resolve <ServiceWithRecursiveLazyDependency1>();
var resolved2 = adapter.Resolve <ServiceWithRecursiveLazyDependency2>();
Assert.Same(resolved2, resolved1.Dependency);
Assert.Same(resolved1, resolved2.Dependency);
}
public void RegisterSingletonFactory()
{
_container = new PillarDefaultIoc();
_container.RegisterSingleton <IFoo>(() => new Foo());
var foo1 = _container.Resolve <IFoo>();
var foo2 = _container.Resolve <IFoo>();
Assert.Same(foo1, foo2);
}
public void LazyanBeUsedToResolveCircularDepenendency(IContainerAdapter adapter)
{
adapter.RegisterSingleton<ServiceWithRecursiveLazyDependency1>();
adapter.RegisterSingleton<ServiceWithRecursiveLazyDependency2>();
var resolved1 = adapter.Resolve<ServiceWithRecursiveLazyDependency1>();
var resolved2 = adapter.Resolve<ServiceWithRecursiveLazyDependency2>();
Assert.Same(resolved2, resolved1.Dependency);
Assert.Same(resolved1, resolved2.Dependency);
}
public void Run <TPresenter>() where TPresenter : class, IPresenter
{
if (!_container.IsRegistered <TPresenter>())
{
_container.Register <TPresenter>();
}
var presenter = _container.Resolve <TPresenter>();
presenter.Run();
}
private static void WarmUp(IContainerAdapter container)
{
var interface1 = (ISingleton)container.Resolve(typeof(ISingleton));
var interface2 = (ITransient)container.Resolve(typeof(ITransient));
var combined = (ICombined)container.Resolve(typeof(ICombined));
if (container.SupportsInterception)
{
var calculator = (ICalculator)container.ResolveProxy(typeof(ICalculator));
calculator.Add(1, 2);
}
}
public void ReuseWithinRequest(IContainerAdapter adapter)
{
adapter.RegisterPerWebRequest <IndependentService>();
BeginRequest(adapter);
var first = adapter.Resolve <IndependentService>();
var second = adapter.Resolve <IndependentService>();
EndRequest(adapter);
Assert.Same(first, second);
}
protected void CanRegisterTwoFluentTypes(Func <IContainerAdapter> adapterFunc)
{
IContainerAdapter adapter = adapterFunc();
var registration = adapter.CreateComponentRegistration <ComponentRegistration>()
.Register <IDependantClass, ISuperDependantClass>()
.As <DependantClass>();
adapter.Register(registration);
Assert.AreEqual(adapter.Resolve <IDependantClass>().GetType(), adapter.Resolve <ISuperDependantClass>().GetType());
Assert.AreEqual(typeof(DependantClass), adapter.Resolve <ISuperDependantClass>().GetType());
Assert.AreEqual(typeof(DependantClass), adapter.Resolve <IDependantClass>().GetType());
}
public void OpenGenericTypes(IContainerAdapter adapter)
{
adapter.RegisterTransient(typeof(IGenericService <>), typeof(GenericService <>));
var resolved = adapter.Resolve <IGenericService <int> >();
Assert.NotNull(resolved);
}
public void PropertyDependencyIsOptional(IContainerAdapter adapter)
{
adapter.RegisterType<ServiceWithSimplePropertyDependency>();
var component = adapter.Resolve<ServiceWithSimplePropertyDependency>();
Assert.Null(component.Service);
}
public void OpenGenericTypes(IContainerAdapter adapter)
{
adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericService<>));
var resolved = adapter.Resolve<IGenericService<int>>();
Assert.NotNull(resolved);
}
public void PropertyDependencyIsOptional(IContainerAdapter adapter)
{
adapter.RegisterType <ServiceWithSimplePropertyDependency>();
var component = adapter.Resolve <ServiceWithSimplePropertyDependency>();
Assert.Null(component.Service);
}
protected override void OnClick(EventArgs e)
{
var form = IoCContainer.Resolve <SettingsForm>();
var result = form.ShowDialog();
if (result == DialogResult.OK)
{
// Save the stuff
var provider = IoCContainer.Resolve <SettingsProvider>();
provider.Save();
}
else
{
form.UndoChanges();
}
}
public void IndependentServiceRegisteredAsSelf(IContainerAdapter adapter)
{
adapter.RegisterType<IndependentService>();
var component = adapter.Resolve<IndependentService>();
Assert.NotNull(component);
}
public void IndependentServiceRegisteredAsSelf(IContainerAdapter adapter)
{
adapter.RegisterType <IndependentService>();
var component = adapter.Resolve <IndependentService>();
Assert.NotNull(component);
}
public IStartableBus CreateBus()
{
FillOutMissingRegistrationsWithDefaults();
ValidateConfiguration();
return(containerAdapter.Resolve <IStartableBus>());
}
/// <summary>
/// 获取指定类型的服务对象
/// </summary>
/// <typeparam name="TService">服务对象类型</typeparam>
/// <returns>服务对象实例</returns>
public static TService GetService <TService>()
{
if (!Container.IsRegistered <TService>())
{
throw new ArgumentException($"服务类型 {typeof(TService)} 未在容器中注册！");
}
return(Container.Resolve <TService>());
}
public void MissingPrimitive(IContainerAdapter adapter)
{
adapter.RegisterType<IService, IndependentService>();
adapter.RegisterType<ServiceWithDependencyAndOptionalInt32Parameter>();
var component = adapter.Resolve<ServiceWithDependencyAndOptionalInt32Parameter>();
Assert.NotNull(component);
}
public void MissingPrimitiveDefaultValue(IContainerAdapter adapter)
{
adapter.RegisterType <IService, IndependentService>();
adapter.RegisterType <ServiceWithDependencyAndOptionalInt32Parameter>();
var component = adapter.Resolve <ServiceWithDependencyAndOptionalInt32Parameter>();
Assert.Equal(5, component.Optional);
}
public void MissingPrimitiveDefaultValue(IContainerAdapter adapter)
{
adapter.RegisterType<IService, IndependentService>();
adapter.RegisterType<ServiceWithDependencyAndOptionalInt32Parameter>();
var component = adapter.Resolve<ServiceWithDependencyAndOptionalInt32Parameter>();
Assert.Equal(5, component.Optional);
}
public void PrebuiltInstance(IContainerAdapter adapter)
{
var instance = new IndependentService();
adapter.RegisterInstance<IService>(instance);
var resolved = adapter.Resolve<IService>();
Assert.Same(instance, resolved);
}
public void MissingPrimitive(IContainerAdapter adapter)
{
adapter.RegisterType <IService, IndependentService>();
adapter.RegisterType <ServiceWithDependencyAndOptionalInt32Parameter>();
var component = adapter.Resolve <ServiceWithDependencyAndOptionalInt32Parameter>();
Assert.NotNull(component);
}
public void NotCreatingLazyPrematurely(IContainerAdapter adapter)
{
adapter.RegisterType <IService, IndependentService>();
adapter.RegisterType <ServiceWithSimpleConstructorDependency>();
var lazy = adapter.Resolve <Lazy <ServiceWithSimpleConstructorDependency> >();
Assert.NotNull(lazy);
Assert.False(lazy.IsValueCreated);
}
public void BasicLazySupport(IContainerAdapter adapter)
{
adapter.RegisterType <IService, IndependentService>();
adapter.RegisterType <ServiceWithSimpleConstructorDependency>();
var lazy = adapter.Resolve <Lazy <ServiceWithSimpleConstructorDependency> >();
Assert.NotNull(lazy);
Assert.NotNull(lazy.Value);
}
public void ConstructorDependencyUsingInstance(IContainerAdapter adapter)
{
var instance = new IndependentService();
adapter.RegisterInstance<IService>(instance);
adapter.RegisterType<ServiceWithSimpleConstructorDependency>();
var dependent = adapter.Resolve<ServiceWithSimpleConstructorDependency>();
Assert.Same(instance, dependent.Service);
}
public void NotCreatingLazyPrematurely(IContainerAdapter adapter)
{
adapter.RegisterType<IService, IndependentService>();
adapter.RegisterType<ServiceWithSimpleConstructorDependency>();
var lazy = adapter.Resolve<Lazy<ServiceWithSimpleConstructorDependency>>();
Assert.NotNull(lazy);
Assert.False(lazy.IsValueCreated);
}
public void BasicLazySupport(IContainerAdapter adapter)
{
adapter.RegisterType<IService, IndependentService>();
adapter.RegisterType<ServiceWithSimpleConstructorDependency>();
var lazy = adapter.Resolve<Lazy<ServiceWithSimpleConstructorDependency>>();
Assert.NotNull(lazy);
Assert.NotNull(lazy.Value);
}
public void ConstructorDependency(IContainerAdapter adapter)
{
adapter.RegisterType<IService, IndependentService>();
adapter.RegisterType<ServiceWithSimpleConstructorDependency>();
var component = adapter.Resolve<ServiceWithSimpleConstructorDependency>();
Assert.NotNull(component.Service);
Assert.IsAssignableFrom<IndependentService>(component.Service);
}
public void PrebuiltInstance(IContainerAdapter adapter)
{
var instance = new IndependentService();
adapter.RegisterInstance <IService>(instance);
var resolved = adapter.Resolve <IService>();
Assert.Same(instance, resolved);
}
/// <summary>
/// Maps the control to the adapter.
/// </summary>
/// <typeparam name="TControl">The type of the control.</typeparam>
/// <typeparam name="TAdapter">The type of the adapter.</typeparam>
/// <returns>
/// A mapper which maps the control to the adapter.
/// </returns>
public RegionAdapterMapper Map <TControl, TAdapter>()
where TAdapter : class, IRegionAdapter
{
if (null != Mappings)
{
Mappings.RegisterMapping(typeof(TControl), m_Container.Resolve <TAdapter>());
}
return(this);
}
public void ConstructorDependency(IContainerAdapter adapter)
{
adapter.RegisterType <IService, IndependentService>();
adapter.RegisterType <ServiceWithSimpleConstructorDependency>();
var component = adapter.Resolve <ServiceWithSimpleConstructorDependency>();
Assert.NotNull(component.Service);
Assert.IsAssignableFrom <IndependentService>(component.Service);
}
public void ComponentIsDisposedAtTheEndOfRequest(IContainerAdapter adapter)
{
adapter.RegisterPerWebRequest<DisposableService>();
BeginRequest(adapter);
var service = adapter.Resolve<DisposableService>();
EndRequest(adapter);
Assert.True(service.Disposed);
}
public void SimpleTransients()
{
var foo = _container.Resolve <IFoo>();
var bar = _container.Resolve <IBar>();
Assert.NotNull(foo);
Assert.NotNull(bar);
Assert.NotNull(bar.InnerFoo);
}
private static long MeasureCombined(IContainerAdapter container)
{
var watch = Stopwatch.StartNew();
for (int i = 0; i < LoopCount; i++)
{
container.Resolve<ICombined>();
}
return watch.ElapsedMilliseconds;
}
public void FactoryWithNoParameters(IContainerAdapter adapter)
{
adapter.RegisterType<IService, IndependentService>();
adapter.RegisterType<ServiceWithSimpleConstructorDependency>();
var func = adapter.Resolve<Func<ServiceWithSimpleConstructorDependency>>();
Assert.NotNull(func);
var result = func();
Assert.NotNull(result);
}
public void TransientFactoryUsedBySingletonStillCreatesTransient(IContainerAdapter adapter)
{
adapter.RegisterTransient <IService, IndependentService>();
adapter.RegisterSingleton <ServiceWithFuncConstructorDependency>();
var service = adapter.Resolve <ServiceWithFuncConstructorDependency>();
var first = service.Factory();
var second = service.Factory();
Assert.NotSame(first, second);
}
public void ConstructorDependencyUsingInstance(IContainerAdapter adapter)
{
var instance = new IndependentService();
adapter.RegisterInstance <IService>(instance);
adapter.RegisterType <ServiceWithSimpleConstructorDependency>();
var dependent = adapter.Resolve <ServiceWithSimpleConstructorDependency>();
Assert.Same(instance, dependent.Service);
}
public void FactoryWithParameterForSubdependency(IContainerAdapter adapter)
{
adapter.RegisterType<ServiceWithSimpleConstructorDependency>();
adapter.RegisterType<ServiceWithDependencyOnServiceWithOtherDependency>();
var service = new IndependentService();
var func = adapter.Resolve<Func<IService, ServiceWithDependencyOnServiceWithOtherDependency>>();
Assert.NotNull(func);
var result = func(service);
Assert.NotNull(result);
Assert.Same(service, result.Service.Service);
}
public void FactoryWithParameter(IContainerAdapter adapter)
{
adapter.RegisterType<IService, IndependentService>();
adapter.RegisterType<ServiceWithTwoConstructorDependencies>();
var service2 = new IndependentService2();
var func = adapter.Resolve<Func<IService2, ServiceWithTwoConstructorDependencies>>();
Assert.NotNull(func);
var result = func(service2);
Assert.NotNull(result);
Assert.Same(service2, result.Service2);
}
public void FactoryNoReuseBetweenRequests(IContainerAdapter adapter)
{
adapter.RegisterPerWebRequest<IService, IndependentService>();
adapter.RegisterSingleton<ServiceWithFuncConstructorDependency>();
var service = adapter.Resolve<ServiceWithFuncConstructorDependency>();
BeginRequest(adapter);
var first = service.Factory();
EndRequest(adapter);
BeginRequest(adapter);
var second = service.Factory();
EndRequest(adapter);
Assert.NotSame(first, second);
}
private static void MeasureResolvePerformance(IContainerAdapter container, Result outputResult)
{
var singletonWatch = new Stopwatch();
var transientWatch = new Stopwatch();
var combinedWatch = new Stopwatch();
var conditionsWatch = new Stopwatch();
var genericWatch = new Stopwatch();
var complexWatch = new Stopwatch();
var multipleWatch = new Stopwatch();
var propertyWatch = new Stopwatch();
var childContainerWatch = new Stopwatch();
for (int i = 0; i < LoopCount; i++)
{
singletonWatch.Start();
var result1 = (ISingleton)container.Resolve(typeof(ISingleton));
singletonWatch.Stop();
transientWatch.Start();
var result2 = (ITransient)container.Resolve(typeof(ITransient));
transientWatch.Stop();
combinedWatch.Start();
var result3 = (ICombined)container.Resolve(typeof(ICombined));
combinedWatch.Stop();
complexWatch.Start();
var complexResult = (IComplex)container.Resolve(typeof(IComplex));
complexWatch.Stop();
if (container.SupportsPropertyInjection)
{
propertyWatch.Start();
var propertyInjectionResult = (IComplexPropertyObject)container.Resolve(typeof(IComplexPropertyObject));
propertyWatch.Stop();
}
if (container.SupportsConditional)
{
conditionsWatch.Start();
var result4 = (ImportConditionObject)container.Resolve(typeof(ImportConditionObject));
var result5 = (ImportConditionObject2)container.Resolve(typeof(ImportConditionObject2));
conditionsWatch.Stop();
}
if (container.SupportGeneric)
{
genericWatch.Start();
var genericResult = (ImportGeneric<int>)container.Resolve(typeof(ImportGeneric<int>));
genericWatch.Stop();
}
if (container.SupportsMultiple)
{
multipleWatch.Start();
var importMultiple = (ImportMultiple)container.Resolve(typeof(ImportMultiple));
multipleWatch.Stop();
}
if (container.SupportsChildContainer && i < ChildContainerLoopCount)
{
// Note I'm writing the test this way specifically because it matches the Per Request bootstrapper for Nance
// It's also a very common pattern used in MVC applications where a scope is created per request
childContainerWatch.Start();
using (var childContainer = container.CreateChildContainerAdapter())
{
childContainer.Prepare();
var scopedCombined = childContainer.Resolve(typeof(ICombined));
}
childContainerWatch.Stop();
}
}
outputResult.SingletonTime = singletonWatch.ElapsedMilliseconds;
outputResult.TransientTime = transientWatch.ElapsedMilliseconds;
outputResult.CombinedTime = combinedWatch.ElapsedMilliseconds;
outputResult.ComplexTime = complexWatch.ElapsedMilliseconds;
if (container.SupportsPropertyInjection)
{
outputResult.PropertyInjectionTime = propertyWatch.ElapsedMilliseconds;
}
if (container.SupportGeneric)
{
outputResult.GenericTime = genericWatch.ElapsedMilliseconds;
}
if (container.SupportsMultiple)
{
outputResult.MultipleImport = multipleWatch.ElapsedMilliseconds;
}
if (container.SupportsConditional)
{
outputResult.ConditionalTime = conditionsWatch.ElapsedMilliseconds;
}
if (container.SupportsChildContainer)
{
outputResult.ChildContainerTime = childContainerWatch.ElapsedMilliseconds * (LoopCount / ChildContainerLoopCount);
}
}
public override void MethodToBenchmark(IContainerAdapter container)
{
var singleton1 = (ISingleton1)container.Resolve(typeof(ISingleton1));
var singleton2 = (ISingleton2)container.Resolve(typeof(ISingleton2));
var singleton3 = (ISingleton3)container.Resolve(typeof(ISingleton3));
}
public override void MethodToBenchmark(IContainerAdapter container)
{
var transient1 = (ITransient1)container.Resolve(typeof(ITransient1));
var transient2 = (ITransient2)container.Resolve(typeof(ITransient2));
var transient3 = (ITransient3)container.Resolve(typeof(ITransient3));
}
static ValidationResult Setup(SplashScreen splashScreen)
{
var validator = new SPFInstalledValidator();
if (validator.RunValidator() == ValidationResult.Error)
{
MessageBox.Show(validator.ErrorString+Environment.NewLine+Environment.NewLine+validator.QuestionString, SPMEnvironment.Version.Title + " Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return ValidationResult.Error;
}
var builder = new ContainerBuilder();
// Find all the assemblies for this application
builder.RegisterModule(new AutoLoadAssemblies());
// Build the container now!
autoFacContainer = builder.Build();
//CompositionProvider.LoadAssemblies();
IoCContainer = autoFacContainer.Resolve<IContainerAdapter>();
var provider = IoCContainer.Resolve<SettingsProvider>();
provider.Load();
var engine = new PreflightController(splashScreen, IoCContainer);
if (!engine.Validate())
{
return ValidationResult.Error;
}
Window = IoCContainer.Resolve<MainWindow>();
Window.SplashScreenLoad(splashScreen);
return ValidationResult.Success;
}
public override void MethodToBenchmark(IContainerAdapter container)
{
var combined1 = (ICombined1)container.Resolve(typeof(ICombined1));
var combined2 = (ICombined2)container.Resolve(typeof(ICombined2));
var combined3 = (ICombined3)container.Resolve(typeof(ICombined3));
}
private static void WarmUp(IContainerAdapter container)
{
var interface1 = container.Resolve<ISingleton>();
var interface2 = container.Resolve<ITransient>();
var combined = container.Resolve<ICombined>();
}
private static void WarmUp(IContainerAdapter container)
{
var interface1 = (ISingleton)container.Resolve(typeof(ISingleton));
if (interface1 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ISingleton)));
}
var interface2 = (ITransient)container.Resolve(typeof(ITransient));
if (interface2 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ITransient)));
}
var combined = (ICombined)container.Resolve(typeof(ICombined));
if (combined == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ICombined)));
}
var complex = (IComplex)container.Resolve(typeof(IComplex));
if (complex == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(IComplex)));
}
if (container.SupportGeneric)
{
var generic = (ImportGeneric<int>)container.Resolve(typeof(ImportGeneric<int>));
if (generic == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ImportGeneric<int>)));
}
}
if (container.SupportsMultiple)
{
var importMultiple = (ImportMultiple)container.Resolve(typeof(ImportMultiple));
if (importMultiple == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ImportMultiple)));
}
}
if (container.SupportsConditional)
{
var importObject = (ImportConditionObject)container.Resolve(typeof(ImportConditionObject));
if (importObject == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ImportConditionObject)));
}
var importObject2 = (ImportConditionObject2)container.Resolve(typeof(ImportConditionObject2));
if (importObject2 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ImportConditionObject2)));
}
}
if (container.SupportsInterception)
{
var calculator = (ICalculator)container.ResolveProxy(typeof(ICalculator));
calculator.Add(1, 2);
}
}
private static void MeasureResolvePerformance(IContainerAdapter container, Result outputResult)
{
var singletonWatch = new Stopwatch();
var transientWatch = new Stopwatch();
var combinedWatch = new Stopwatch();
var conditionsWatch = new Stopwatch();
var genericWatch = new Stopwatch();
var complexWatch = new Stopwatch();
var multipleWatch = new Stopwatch();
for (int i = 0; i < LoopCount; i++)
{
singletonWatch.Start();
var result1 = (ISingleton)container.Resolve(typeof(ISingleton));
singletonWatch.Stop();
transientWatch.Start();
var result2 = (ITransient)container.Resolve(typeof(ITransient));
transientWatch.Stop();
combinedWatch.Start();
var result3 = (ICombined)container.Resolve(typeof(ICombined));
combinedWatch.Stop();
complexWatch.Start();
var complexResult = (IComplex)container.Resolve(typeof(IComplex));
complexWatch.Stop();
if (container.SupportsConditional)
{
conditionsWatch.Start();
var result4 = (ImportConditionObject)container.Resolve(typeof(ImportConditionObject));
var result5 = (ImportConditionObject2)container.Resolve(typeof(ImportConditionObject2));
conditionsWatch.Stop();
}
if (container.SupportGeneric)
{
genericWatch.Start();
var genericResult = (ImportGeneric<int>)container.Resolve(typeof(ImportGeneric<int>));
genericWatch.Stop();
}
if (container.SupportsMultiple)
{
multipleWatch.Start();
var importMultiple = (ImportMultiple)container.Resolve(typeof(ImportMultiple));
multipleWatch.Stop();
}
}
outputResult.SingletonTime = singletonWatch.ElapsedMilliseconds;
outputResult.TransientTime = transientWatch.ElapsedMilliseconds;
outputResult.CombinedTime = combinedWatch.ElapsedMilliseconds;
outputResult.ComplexTime = complexWatch.ElapsedMilliseconds;
if (container.SupportGeneric)
{
outputResult.GenericTime = genericWatch.ElapsedMilliseconds;
}
if (container.SupportsMultiple)
{
outputResult.MultipleImport = multipleWatch.ElapsedMilliseconds;
}
if (container.SupportsConditional)
{
outputResult.ConditionalTime = conditionsWatch.ElapsedMilliseconds;
}
}
public void TransientLifetime(IContainerAdapter adapter)
{
adapter.RegisterTransient<IService, IndependentService>();
var instance1 = adapter.Resolve<IService>();
var instance2 = adapter.Resolve<IService>();
Assert.NotSame(instance1, instance2);
}
private static void WarmUp(IContainerAdapter container)
{
var interface1 = (ISingleton)container.Resolve(typeof(ISingleton));
if (interface1 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ISingleton)));
}
var interface2 = (ITransient)container.Resolve(typeof(ITransient));
if (interface2 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ITransient)));
}
var combined = (ICombined)container.Resolve(typeof(ICombined));
if (combined == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ICombined)));
}
var complex = (IComplex)container.Resolve(typeof(IComplex));
if (complex == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(IComplex)));
}
if (container.SupportsPropertyInjection)
{
var propertyInjectionObject = (ComplexPropertyObject)container.Resolve(typeof(IComplexPropertyObject));
var propertyInjectionObject2 = (ComplexPropertyObject)container.Resolve(typeof(IComplexPropertyObject));
if (propertyInjectionObject == null || propertyInjectionObject2 == null)
{
throw new Exception(
string.Format(
"Container {0} could not create type {1}",
container.PackageName,
typeof(IComplexPropertyObject)));
}
if (object.ReferenceEquals(propertyInjectionObject, propertyInjectionObject2) ||
!object.ReferenceEquals(propertyInjectionObject.ServiceA, propertyInjectionObject2.ServiceA) ||
!object.ReferenceEquals(propertyInjectionObject.ServiceB, propertyInjectionObject2.ServiceB) ||
!object.ReferenceEquals(propertyInjectionObject.ServiceC, propertyInjectionObject2.ServiceC) ||
object.ReferenceEquals(propertyInjectionObject.SubObjectA, propertyInjectionObject2.SubObjectA) ||
object.ReferenceEquals(propertyInjectionObject.SubObjectB, propertyInjectionObject2.SubObjectB) ||
object.ReferenceEquals(propertyInjectionObject.SubObjectC, propertyInjectionObject2.SubObjectC))
{
throw new Exception(
string.Format(
"Container {0} could not correctly create type {1}",
container.PackageName,
typeof(IComplexPropertyObject)));
}
propertyInjectionObject.Verify(container.PackageName);
}
if (container.SupportGeneric)
{
var generic = (ImportGeneric<int>)container.Resolve(typeof(ImportGeneric<int>));
if (generic == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ImportGeneric<int>)));
}
}
if (container.SupportsMultiple)
{
var importMultiple = (ImportMultiple)container.Resolve(typeof(ImportMultiple));
if (importMultiple == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ImportMultiple)));
}
}
if (container.SupportsConditional)
{
var importObject = (ImportConditionObject)container.Resolve(typeof(ImportConditionObject));
if (importObject == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ImportConditionObject)));
}
var importObject2 = (ImportConditionObject2)container.Resolve(typeof(ImportConditionObject2));
if (importObject2 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.PackageName, typeof(ImportConditionObject2)));
}
}
if (container.SupportsInterception)
{
var calculator = (ICalculator)container.ResolveProxy(typeof(ICalculator));
calculator.Add(1, 2);
}
if (container.SupportsChildContainer)
{
using (var childContainer = container.CreateChildContainerAdapter())
{
childContainer.Prepare();
ICombined scopedCombined = (ICombined)childContainer.Resolve(typeof(ICombined));
if (scopedCombined == null)
{
throw new Exception(string.Format("Child Container {0} could not create type {1}", container.PackageName, typeof(ICombined)));
}
if (!(scopedCombined is ScopedCombined))
{
throw new Exception(string.Format("Child Container {0} resolved type incorrectly should have been {1} but was {2}", container.PackageName, typeof(ICombined), scopedCombined.GetType()));
}
}
}
}