public void OpenGenericTypes(IContainerAdapter adapter)
{
adapter.RegisterTransient(typeof(IGenericService <>), typeof(GenericService <>));
var resolved = adapter.Resolve <IGenericService <int> >();
Assert.NotNull(resolved);
}
public Result(IContainerAdapter containerAdapter, string name, string version)
{
Name = name;
Version = version;
_containerAdapter = containerAdapter;
containerAdapter.Prepare();
}
public SettingsTreeView(IContainerAdapter container)
{
IoCContainer = container;
ShowNodeToolTips = true;
HideSelection = false;
Dock = DockStyle.Fill;
}
protected ServiceStackAppHostBase(
IContainerAdapter containerAdapter,
string serviceName, params Assembly[] assembliesWithServices)
: base(serviceName, 50, 5000, assembliesWithServices)
{
this.containerAdapter = containerAdapter;
}
public void RunTest(IContainerAdapter container, Action <IContainerAdapter> actionToBenchmark, int numberOfThreads)
{
Stopwatch sw = new Stopwatch();
Warmup2(container);
var count = 500000 / numberOfThreads;
actionToBenchmark(container); // Run once to prepare method
var threads = new List <Thread>();
for (int i = 0; i < numberOfThreads; i++)
{
threads.Add(new Thread(() =>
{
for (var j = 0; j < count; j++)
{
actionToBenchmark(container);
}
}));
}
sw.Start();
threads.ForEach(t => t.Start());
threads.ForEach(t => t.Join());
sw.Stop();
Console.WriteLine(actionToBenchmark.Method.Name + " using " + numberOfThreads + " threads: " + sw.ElapsedMilliseconds);
}
public virtual void Warmup(IContainerAdapter container)
{
this.MethodToBenchmark(container);
ScopedCombined1.Instances = 0;
ScopedCombined2.Instances = 0;
ScopedCombined3.Instances = 0;
Complex1.Instances = 0;
Complex2.Instances = 0;
Complex3.Instances = 0;
ImportConditionObject1.Instances = 0;
ImportConditionObject2.Instances = 0;
ImportConditionObject3.Instances = 0;
ImportGeneric <int> .Instances = 0;
ImportGeneric <float> .Instances = 0;
ImportGeneric <object> .Instances = 0;
ImportMultiple1.Instances = 0;
ImportMultiple2.Instances = 0;
ImportMultiple3.Instances = 0;
ComplexPropertyObject1.Instances = 0;
ComplexPropertyObject2.Instances = 0;
ComplexPropertyObject3.Instances = 0;
Calculator1.Instances = 0;
Calculator2.Instances = 0;
Calculator3.Instances = 0;
Combined1.Instances = 0;
Combined2.Instances = 0;
Combined3.Instances = 0;
Singleton1.Instances = 0;
Singleton2.Instances = 0;
Singleton3.Instances = 0;
Transient1.Instances = 0;
Transient2.Instances = 0;
Transient3.Instances = 0;
}
public void PrepareAndRegisterAndSimpleResolve(IContainerAdapter container)
{
container.PrepareBasic();
container.Resolve(typeof(IBasicService1));
container.Resolve(typeof(ISingleton1));
container.Dispose();
}
public void OpenGenericTypes(IContainerAdapter adapter)
{
adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericService<>));
var resolved = adapter.Resolve<IGenericService<int>>();
Assert.NotNull(resolved);
}
public AboutMenuItem(IContainerAdapter container, ISPMLocalization local)
{
IoCContainer = container;
Text = local.GetText("Interface_About_Text");
ToolTipText = local.GetText("Interface_About_ToolTip");
Image = global::Keutmann.SharePointManager.Properties.Resources.about;
}
public void GetAssemblyScannedAdapter()
{
IContainerAdapterAccessor adapterAccessor = new ContainerAdapterAccessor(true);
IContainerAdapter adapter = adapterAccessor.GetAdapter(TestConstants.AutofacContainerName);
Assert.IsNotNull(adapter);
}
private static void CheckInstanceProperties(IContainerAdapter container)
{
if (Singleton.Instances != 1)
{
throw new Exception("Singleton instance count must be one");
}
if (Transient.Instances < (LoopCount * 2) + 1 || Transient.Instances > (LoopCount * 2) + 4)
{
throw new Exception(
string.Format("Transient count must be between {0} and {1} was {2}", (LoopCount * 2) + 1, (LoopCount * 2) + 4, Transient.Instances));
}
if (Combined.Instances != LoopCount + 1 && Combined.Instances != LoopCount + 2)
{
throw new Exception(string.Format("Combined count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Combined.Instances));
}
if (Complex.Instances != LoopCount + 1 && Complex.Instances != LoopCount + 2)
{
throw new Exception(string.Format("Complex count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Complex.Instances));
}
if (container.SupportsInterception)
{
if (Calculator.Instances != LoopCount + 1 && Calculator.Instances != LoopCount + 2)
{
throw new Exception(string.Format("Calculator count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Calculator.Instances));
}
}
}
public TreeViewComponent(IContainerAdapter container)
{
IoCContainer = container;
this.ShowNodeToolTips = true;
this.HideSelection = false;
ViewLevel = 50;
}
public static void Initialize(IMongoClient client, IContainerAdapter containerAdapter)
{
var componentRegistry = new ComponentRegistry(new MongoMigrationSettings(), containerAdapter);
componentRegistry.RegisterComponents(client);
Initialize(componentRegistry);
}
public void Configure(IContainerAdapter containerAdapter)
{
containerAdapter.Register <IVirtualPathUtilityService, VirtualPathUtilityService>();
//containerAdapter.Register<ILocalState, HttpLocalState>();
//containerAdapter.Register<ICacheState, HttpRuntimeCache>();
//containerAdapter.Register<ISessionState, HttpSessionState>();
}
public SaveAllMenuItem(IContainerAdapter container, ISPMLocalization local)
: base(container)
{
Text = local.GetText("Interface_SaveAll_Text");
ToolTipText = local.GetText("Interface_SaveAll_ToolTip");
Image = global::Keutmann.SharePointManager.Properties.Resources.saveall;
}
public AboutMenuItem(IContainerAdapter container, ISPMLocalization local)
{
IoCContainer = container;
Text = local.GetText("Interface_About_Text");
ToolTipText = local.GetText("Interface_About_ToolTip");
Image = global::Keutmann.SharePointManager.Properties.Resources.about;
}
//Func<CustomUnitOfWorkSettings, ITransactionManager> getTransactionManager;
/// <summary>
/// Configures <see cref="UnitOfWorkScope"/> settings.
/// </summary>
/// <param name="containerAdapter">The <see cref="IContainerAdapter"/> instance.</param>
public void Configure(IContainerAdapter containerAdapter)
{
var settings = new CustomUnitOfWorkSettings()
{
AutoCompleteScope = _autoCompleteScope, DefaultIsolation = _defaultIsolation
};
containerAdapter.RegisterInstance(settings);
containerAdapter.RegisterSingleton <IUnityUnitOfWorkManager, UnityUnitOfWorkManager>();
//containerAdapter.RegisterInstance<ITransactionManager>(getTransactionManager(settings));
containerAdapter.RegisterInstance <IUnitOfWorkGuid>(new UnitOfWorkGuid());
containerAdapter.RegisterSingleton <IUnitOfWorkScopeFactory, UnityUnitOfWorkScopeFactory>();
containerAdapter.Register <IUnitOfWorkScope, UnityUnitOfWorkScope>();
//UnitOfWorkSettings.AutoCompleteScope = _autoCompleteScope;
//UnitOfWorkSettings.DefaultIsolation = _defaultIsolation;
if (_useBusinessTransaction)
{
containerAdapter.RegisterSingleton <IBusinessTransactionObservable, BusinessTransactionSubjectWrapper>();
containerAdapter.RegisterSingleton <IBusinessTransactionSubscriber, BusinessTransactionSubjectWrapper>();
containerAdapter.RegisterInstance <IBusinessTransactionSubjectFactory>(new BusinessTransactionSubjectFactory(() => new BusinessTransactionSubject()));
}
else
{
var subject = new StubTransactionSubject();
containerAdapter.RegisterInstance <IBusinessTransactionObservable>(subject);
containerAdapter.RegisterInstance <IBusinessTransactionSubscriber>(subject);
containerAdapter.RegisterInstance <IBusinessTransactionSubjectFactory>(new BusinessTransactionSubjectFactory(() => subject));
}
//IBusinessTransactionSubject subject = !_useBusinessTransaction? new StubTransactionSubject(): new BusinessTransactionSubjectWrapper();
//containerAdapter.RegisterInstance<IBusinessTransactionSubjectFactory>(new BusinessTransactionSubjectFactory(!_useBusinessTransaction ? () => subject : () => new BusinessTransactionSubject()));
}
/// <summary>
/// Called by RCommon <see cref="Configure"/> to configure state storage.
/// </summary>
/// <param name="containerAdapter">The <see cref="IContainerAdapter"/> instance that can be
/// used to register state storage components.</param>
public void Configure(IContainerAdapter containerAdapter)
{
if (_customSessionType != null)
{
containerAdapter.AddTransient(typeof(ISessionState), _customSessionType);
}
else
{
containerAdapter.AddTransient <ISessionStateSelector, DefaultSessionStateSelector>();
containerAdapter.AddTransient <ISessionState, SessionStateWrapper>();
}
if (_customLocalStateType != null)
{
containerAdapter.AddTransient(typeof(IContextState), _customLocalStateType);
}
else
{
containerAdapter.AddTransient <IContextStateSelector, DefaultContextStateSelector>();
containerAdapter.AddTransient <IContextState, ContextStateWrapper>();
}
if (_customApplicationStateType != null)
{
containerAdapter.AddSingleton(typeof(IApplicationState), _customApplicationStateType);
}
else
{
containerAdapter.AddSingleton <IApplicationState, ApplicationState>();
}
containerAdapter.AddTransient <IStateStorage, StateStorageWrapper>();
}
public void IndependentServiceRegisteredAsSelf(IContainerAdapter adapter)
{
adapter.RegisterType<IndependentService>();
var component = adapter.Resolve<IndependentService>();
Assert.NotNull(component);
}
public SettingsTreeView(IContainerAdapter container)
{
IoCContainer = container;
ShowNodeToolTips = true;
HideSelection = false;
Dock = DockStyle.Fill;
}
private static Result MeasurePerformance(string name, IContainerAdapter container)
{
CollectMemory();
container.Prepare();
WarmUp(container);
var result = new Result();
result.Name = name;
result.Version = container.Version;
result.SingletonTime = MeasureSingleton(container);
result.TransientTime = MeasureTransient(container);
result.CombinedTime = MeasureCombined(container);
if (container.SupportsInterception)
{
result.InterceptionTime = MeasureProxy(container);
}
result.SingletonInstances = Singleton.Instances;
result.TransientInstances = Transient.Instances;
result.CombinedInstances = Combined.Instances;
result.InterceptionInstances = Calculator.Instances;
Singleton.Instances = 0;
Transient.Instances = 0;
Combined.Instances = 0;
Calculator.Instances = 0;
container.Dispose();
return result;
}
public void PropertyDependencyIsOptional(IContainerAdapter adapter)
{
adapter.RegisterType <ServiceWithSimplePropertyDependency>();
var component = adapter.Resolve <ServiceWithSimplePropertyDependency>();
Assert.Null(component.Service);
}
public void Configure(IContainerAdapter containerAdapter)
{
// Register all of the domain services with the Dependency Injection Container.
containerAdapter.AddTransient <IDiveLocationService, DiveLocationService>();
containerAdapter.AddTransient <IDiveTypeService, DiveTypeService>();
containerAdapter.AddTransient <IUserService, UserService>();
}
public DependencyInjectionFixture()
{
_container = new PillarDefaultIoc();
_container.RegisterType <IFoo, Foo>();
_container.RegisterType <IBar, Bar>();
}
private static void CheckInstanceProperties(IContainerAdapter container)
{
if (Singleton.Instances != 1)
{
throw new Exception("Singleton instance count must be one");
}
if (Transient.Instances < (LoopCount * 2) + 1 || Transient.Instances > (LoopCount * 2) + 4)
{
throw new Exception(
string.Format("Transient count must be between {0} and {1} was {2}", (LoopCount * 2) + 1, (LoopCount * 2) + 4, Transient.Instances));
}
if (Combined.Instances != LoopCount + 1 && Combined.Instances != LoopCount + 2)
{
throw new Exception(string.Format("Combined count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Combined.Instances));
}
if (Complex.Instances != LoopCount + 1 && Complex.Instances != LoopCount + 2)
{
throw new Exception(string.Format("Complex count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Complex.Instances));
}
if (container.SupportsInterception)
{
if (Calculator.Instances != LoopCount + 1 && Calculator.Instances != LoopCount + 2)
{
throw new Exception(string.Format("Calculator count must be {0} or {1} was {2}", LoopCount + 1, LoopCount + 2, Calculator.Instances));
}
}
}
public SaveAllMenuItem(IContainerAdapter container, ISPMLocalization local)
: base(container)
{
Text = local.GetText("Interface_SaveAll_Text");
ToolTipText = local.GetText("Interface_SaveAll_ToolTip");
Image = global::Keutmann.SharePointManager.Properties.Resources.saveall;
}
private static Result MeasurePerformance(string name, IContainerAdapter container)
{
ClearInstanceProperties();
CollectMemory();
container.Prepare();
WarmUp(container);
var result = new Result();
result.Name = name;
result.Version = container.Version;
MeasureResolvePerformance(container, result);
if (container.SupportsInterception)
{
result.InterceptionTime = MeasureProxy(container);
}
CheckInstanceProperties(container);
container.Dispose();
return(result);
}
private void PopulateAdaptersInAssembly(Assembly assembly)
{
IEnumerable <Type> potentialAdapters;
try
{
potentialAdapters = assembly.GetTypes().Where(IsPotentialAdapter);
}
catch
{
return;
}
foreach (Type potentialAdapter in potentialAdapters)
{
ConstructorInfo constructor = potentialAdapter.GetConstructor(Type.EmptyTypes);
if (potentialAdapter.IsAbstract || constructor == null)
{
continue;
}
IContainerAdapter adapter = Activator.CreateInstance(potentialAdapter) as IContainerAdapter;
if (adapter == null || !adapter.AllowSelfRegistration)
{
continue;
}
AddAdapter(adapter.Name, adapter);
}
}
public TreeViewComponent(IContainerAdapter container)
{
IoCContainer = container;
this.ShowNodeToolTips = true;
this.HideSelection = false;
ViewLevel = 50;
}
public void PropertyDependencyIsOptional(IContainerAdapter adapter)
{
adapter.RegisterType<ServiceWithSimplePropertyDependency>();
var component = adapter.Resolve<ServiceWithSimplePropertyDependency>();
Assert.Null(component.Service);
}
public BenchmarkRunner(IContainerAdapter container, IBenchmark benchmark)
{
this.container = container;
this.benchmark = benchmark;
this.singlethreadedMeasurer = new SinglethreadedBenchmarkMeasurer(container, benchmark);
this.multithreadedMeasurer = new MultithreadedBenchmarkMeasurer(container, benchmark);
}
private static void MeasurePerformance(string name, IContainerAdapter container)
{
CollectMemory();
container.Prepare();
WarmUp(container);
long singletonTime = MeasureSingleton(container);
long transientTime = MeasureTransient(container);
long combinedTime = MeasureCombined(container);
Console.WriteLine(string.Format(
"{0}\t{1}\t\t{2}\t\t{3}\t\t{4}\t\t\t{5}\t\t\t\t{6}",
name + " ".Substring(name.Length - 1),
singletonTime,
transientTime,
combinedTime,
Singleton.Instances,
Transient.Instances,
Combined.Instances));
Singleton.Instances = 0;
Transient.Instances = 0;
Combined.Instances = 0;
container.Dispose();
}
public override void MethodToBenchmark(IContainerAdapter container)
{
container.PrepareBasic();
container.Resolve(typeof(IDummyOne));
container.Resolve(typeof(ISingleton1));
container.Dispose();
}
IBus CreateBus(string serviceName, IContainerAdapter containerAdapter)
{
var sagaCollectionName = serviceName + ".sagas";
var subscriptionsCollectionName = "rebus.subscriptions";
DropCollection(sagaCollectionName);
DropCollection(subscriptionsCollectionName);
var inputQueueName = GetEndpoint(serviceName);
var queue = messageQueueFactory.GetQueue(inputQueueName);
var sagaPersister = new MongoDbSagaPersister(ConnectionString)
.SetCollectionName <CheckCreditSagaData>("check_credit_sagas")
.SetCollectionName <CheckSomeLegalStuffSagaData>("check_legal_sagas")
.SetCollectionName <CustomerInformationSagaData>("customer_information_sagas");
var bus = new RebusBus(containerAdapter, queue.Item1, queue.Item2,
new MongoDbSubscriptionStorage(ConnectionString, subscriptionsCollectionName),
sagaPersister, this,
new JsonMessageSerializer(), new TrivialPipelineInspector(),
new ErrorTracker("error"));
stuffToDispose.Add(bus);
containerAdapter.RegisterInstance(bus, typeof(IBus));
return(bus.Start(5));
}
public BenchmarkRunner(IContainerAdapter container, IBenchmark benchmark)
{
this.container = container;
this.benchmark = benchmark;
this.singlethreadedMeasurer = new SinglethreadedBenchmarkMeasurer(container, benchmark);
this.multithreadedMeasurer = new MultithreadedBenchmarkMeasurer(container, benchmark);
}
public void IndependentServiceRegisteredAsSelf(IContainerAdapter adapter)
{
adapter.RegisterType <IndependentService>();
var component = adapter.Resolve <IndependentService>();
Assert.NotNull(component);
}
public MainMenuStrip(IContainerAdapter container)
{
this.TabIndex = 0;
var items = container.ResolveBind<IMenuItem>(this.GetType());
this.Items.AddRange(items.Cast<ToolStripItem>().ToArray());
}
public SPNodeProvider(SPFarm farm, IEnumerable <IRule <ISPNode> > rules, IContainerAdapter container)
{
ViewLevel = 100;
Farm = farm;
IoCContainer = container;
_ruleEngine = new FirstAcceptRuleEngine <ISPNode>(rules);
}
public void PropertyDependencyDoesNotNeedCustomAttribute(IContainerAdapter adapter)
{
var property = typeof(ServiceWithSimplePropertyDependency).GetProperty("Service");
var attributes = property.GetCustomAttributes(false);
var attributesFromThisFramework = attributes.Where(a => a.GetType().Assembly == adapter.Assembly);
Assert.Empty(attributesFromThisFramework);
}
public void TransientLifetime(IContainerAdapter adapter)
{
adapter.RegisterTransient <IService, IndependentService>();
var instance1 = adapter.Resolve <IService>();
var instance2 = adapter.Resolve <IService>();
Assert.NotSame(instance1, instance2);
}
public SPNodeProvider(SPFarm farm, IEnumerable<IRule<ISPNode>> rules, IContainerAdapter container)
{
ViewLevel = 100;
Farm = farm;
IoCContainer = container;
_ruleEngine = new FirstAcceptRuleEngine<ISPNode>(rules);
}
public void SingletonLifetime(IContainerAdapter adapter)
{
adapter.RegisterSingleton <IService, IndependentService>();
var instance1 = adapter.Resolve <IService>();
var instance2 = adapter.Resolve <IService>();
Assert.Same(instance1, instance2);
}
protected override void DoSetUp()
{
SomeDisposable.Reset();
Console.WriteLine("Running setup for {0}", typeof(TFactory));
factory = new TFactory();
adapter = factory.Create();
RebusLoggerFactory.Current = new ConsoleLoggerFactory(false);
}
public void LoadModel(IContainerAdapter container)
{
Model = new MenuItemViewModel(container, this.GetType());
if (Model.Items != null && Model.Items.Count() > 0)
{
this.DropDownItems.AddRange(Model.Items.Cast <ToolStripItem>().ToArray());
}
}
public void PropertyDependencyDoesNotNeedCustomAttribute(IContainerAdapter adapter)
{
var property = typeof(ServiceWithSimplePropertyDependency).GetProperty("Service");
var attributes = property.GetCustomAttributes(false);
var attributesFromThisFramework = attributes.Where(a => a.GetType().Assembly == adapter.Assembly);
Assert.Empty(attributesFromThisFramework);
}
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 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 MissingPrimitiveDefaultValue(IContainerAdapter adapter)
{
adapter.RegisterType<IService, IndependentService>();
adapter.RegisterType<ServiceWithDependencyAndOptionalInt32Parameter>();
var component = adapter.Resolve<ServiceWithDependencyAndOptionalInt32Parameter>();
Assert.Equal(5, component.Optional);
}
public void ConstrainsForOpenGenerics(IContainerAdapter adapter)
{
adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericService<>));
adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericServiceWithIService2Constraint<>));
var resolved = adapter.ResolveAll<IGenericService<IndependentService>>().ToArray();
Assert.Equal(1, resolved.Length);
Assert.IsType<GenericService<IndependentService>>(resolved[0]);
}
public MainWindow(IContainerAdapter container)
{
Text = SPMEnvironment.Version.Title;
IoCContainer = container;
InitializeComponent();
Shown += MainWindow_Shown;
Load +=new EventHandler(MainWindow_Load);
}
public TimerServiceValidator(IContainerAdapter container)
: base()
{
IoCContainer = container;
this.QuestionString = "The application needs to run on a frontend server with SharePoint Foundation installed";
this.SuccessString = "Microsoft SharePoint Timer Service found";
this.ErrorString = "Microsoft SharePoint Timer Service missing";
}
/// <summary>
/// Adds an adapter for serving
/// </summary>
/// <param name="key">The adapter key</param>
/// <param name="adapter">The adapter</param>
public void AddAdapter(string key, IContainerAdapter adapter)
{
if (adapters.ContainsKey(key))
{
throw new InvalidDataException("An adapter has already been registered with this key");
}
adapters.Add(key, adapter);
}
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 ComponentIsDisposedAtTheEndOfRequest(IContainerAdapter adapter)
{
adapter.RegisterPerWebRequest<DisposableService>();
BeginRequest(adapter);
var service = adapter.Resolve<DisposableService>();
EndRequest(adapter);
Assert.True(service.Disposed);
}
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 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 ConstructorDependencyUsingInstance(IContainerAdapter adapter)
{
var instance = new IndependentService();
adapter.RegisterInstance<IService>(instance);
adapter.RegisterType<ServiceWithSimpleConstructorDependency>();
var dependent = adapter.Resolve<ServiceWithSimpleConstructorDependency>();
Assert.Same(instance, dependent.Service);
}
