public void GetAllGenericReturnsExpectedRegistrations()
{
var reg1 = new InstanceRegistration <IFoo>(new Foo1());
var reg2 = new InstanceRegistration <IFoo>(new Foo1(), "Key1");
var reg3 = new InstanceRegistration <IFoo>(new Foo1(), "Key2");
var reg4 = new InstanceRegistration <IBar>(new Bar1(), "Key1");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
index.Add(reg3);
index.Add(reg4);
var all = index.GetAll <IFoo>();
Assert.IsInstanceOfType(all, typeof(IEnumerable <IRegistration>));
Assert.IsTrue(all.Count() == 3);
var allList = all.ToList();
CollectionAssert.AllItemsAreNotNull(allList);
CollectionAssert.AllItemsAreInstancesOfType(allList, typeof(InstanceRegistration <IFoo>));
CollectionAssert.Contains(allList, reg1);
CollectionAssert.Contains(allList, reg2);
CollectionAssert.Contains(allList, reg3);
CollectionAssert.DoesNotContain(allList, reg4);
}
}
public void GetAllGenericThrowsExceptionIfTypeIsNotRegistered()
{
var reg1 = new InstanceRegistration <IFoo>(new Foo1());
var reg2 = new InstanceRegistration <IFoo>(new Foo1(), "Key");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
try
{
var result = index.GetAll <IBar>();
// Doesnt throw exception before it is enumerated because it uses yield return - OK ?
var test = result.Count();
// Should never get here if exception is thrown
Assert.IsTrue(false);
}
catch (KeyNotFoundException)
{
}
}
}
/// <summary>
/// Register an instance with the container.
/// </summary>
/// <remarks> <para>
/// Instance registration is much like setting a type as a singleton, except that instead
/// of the container creating the instance the first time it is requested, the user
/// creates the instance ahead of type and adds that instance to the container.
/// </para></remarks>
/// <param name="registrationType">Type of instance to register (may be an implemented interface instead of the full type).</param>
/// <param name="instance">Object to be returned.</param>
/// <param name="registrationName">Name for registration.</param>
/// <param name="lifetimeManager">
/// <para>If null or <see cref="ContainerControlledLifetimeManager"/>, the container will take over the lifetime of the instance,
/// calling Dispose on it (if it's <see cref="IDisposable"/>) when the container is Disposed.</para>
/// <para>
/// If <see cref="ExternallyControlledLifetimeManager"/>, container will not maintain a strong reference to <paramref name="instance"/>.
/// User is responsible for disposing instance, and for keeping the instance typeFrom being garbage collected.</para></param>
/// <returns>The <see cref="UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns>
public IUnityContainer RegisterInstance(Type registrationType, string registrationName, object instance, LifetimeManager lifetimeManager)
{
// Validate imput
if (string.Empty == registrationName)
{
registrationName = null;
}
if (null == instance)
{
throw new ArgumentNullException(nameof(instance));
}
// Create registration and add to appropriate storage
var registration = new InstanceRegistration(registrationType, registrationName, instance, lifetimeManager);
var container = (lifetimeManager is ISingletonLifetimePolicy) ? GetRootContainer() : this;
// Add or replace existing
if (container.SetOrUpdate(registration) is IDisposable disposable)
{
container._lifetimeContainer.Remove(disposable);
disposable.Dispose();
}
if (registration.LifetimeManager is IDisposable manager)
{
container._lifetimeContainer.Add(manager);
}
// Raise event
container.RegisteringInstance?.Invoke(this, new RegisterInstanceEventArgs(registration.RegisteredType, instance,
registration.Name, registration.LifetimeManager));
return(this);
}
public void GetAllThrowsExceptionIfTypeIsNotRegistered()
{
var reg1 = new InstanceRegistration<IFoo>(new Foo1());
var reg2 = new InstanceRegistration<IFoo>(new Foo1(), "Key");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
try
{
var result = index.GetAll(typeof(IBar));
// Doesnt throw exception before it is enumerated because it uses yield return - OK ?
var test = result.Count();
// Should never get here if exception is thrown
Assert.IsTrue(false);
}
catch (KeyNotFoundException)
{
}
}
}
public void TryGetAllGenericReturnsExpectedRegistrations()
{
var reg1 = new InstanceRegistration<IFoo>(new Foo1());
var reg2 = new InstanceRegistration<IFoo>(new Foo1(), "Key1");
var reg3 = new InstanceRegistration<IFoo>(new Foo1(), "Key2");
var reg4 = new InstanceRegistration<IBar>(new Bar1(), "Key1");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
index.Add(reg3);
index.Add(reg4);
var all = index.TryGetAll<IFoo>();
Assert.IsInstanceOfType(all, typeof(IEnumerable<IRegistration>));
Assert.IsTrue(all.Count() == 3);
var allList = all.ToList();
CollectionAssert.AllItemsAreNotNull(allList);
CollectionAssert.AllItemsAreInstancesOfType(allList, typeof(InstanceRegistration<IFoo>));
CollectionAssert.Contains(allList, reg1);
CollectionAssert.Contains(allList, reg2);
CollectionAssert.Contains(allList, reg3);
CollectionAssert.DoesNotContain(allList, reg4);
}
}
public void TryGetGenericReturnTheExpectedRegistration()
{
var reg1 = new InstanceRegistration<IFoo>(new Foo1());
var reg2 = new InstanceRegistration<IFoo>(new Foo1());
var reg3 = new InstanceRegistration<IFoo>(new Foo1());
var reg4 = new InstanceRegistration<IBar>(new Bar1());
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2, "Key1");
index.Add(reg3, "Key2");
index.Add(reg4, "Key1");
IRegistration out1;
var result1 = index.TryGet<IFoo>(out out1);
IRegistration out2;
var result2 = index.TryGet<IFoo>("Key2", out out2);
Assert.IsTrue(result1);
Assert.IsTrue(result2);
Assert.IsNotNull(out1);
Assert.IsNotNull(out2);
Assert.AreSame(reg1, out1);
Assert.AreSame(reg3, out2);
}
}
public void TryGetReturnTheExpectedRegistration()
{
var reg1 = new InstanceRegistration<IFoo>(new Foo1());
var reg2 = new InstanceRegistration<IFoo>(new Foo1(), "Key1");
var reg3 = new InstanceRegistration<IFoo>(new Foo1(), "Key2");
var reg4 = new InstanceRegistration<IBar>(new Bar1(), "Key1");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
index.Add(reg3);
index.Add(reg4);
IRegistration out1;
var result1 = index.TryGet(typeof(IFoo), out out1);
IRegistration out2;
var result2 = index.TryGet(typeof(IFoo), "Key2", out out2);
Assert.IsTrue(result1);
Assert.IsTrue(result2);
Assert.IsInstanceOfType(out1, typeof(IRegistration));
Assert.IsInstanceOfType(out2, typeof(IRegistration));
Assert.AreSame(reg1, out1);
Assert.AreSame(reg3, out2);
}
}
public void AddWorksLikeExpected()
{
var reg1 = new InstanceRegistration <IFoo>(new Foo1());
var reg2 = new InstanceRegistration <IBar>(new Bar1());
var reg3 = new InstanceRegistration <IBar>(new Bar1(), "Key");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
index.Add(reg3);
Assert.IsTrue(index.Count() == 3);
// Really dont need to include rest of the checks - covered by other tests - nothing to do with add
var registrations = index.ToList();
CollectionAssert.AllItemsAreNotNull(registrations);
CollectionAssert.AllItemsAreUnique(registrations);
CollectionAssert.Contains(registrations, reg1);
CollectionAssert.Contains(registrations, reg2);
CollectionAssert.Contains(registrations, reg3);
var out1 = index.Get(typeof(IFoo));
var out2 = index.Get(typeof(IBar));
var out3 = index.Get(typeof(IBar), "Key");
Assert.AreSame(out1, reg1);
Assert.AreSame(out2, reg2);
Assert.AreSame(out3, reg3);
}
}
public void AddWorksLikeExpected()
{
var reg1 = new InstanceRegistration<IFoo>(new Foo1());
var reg2 = new InstanceRegistration<IBar>(new Bar1());
var reg3 = new InstanceRegistration<IBar>(new Bar1(), "Key");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
index.Add(reg3);
Assert.IsTrue(index.Count() == 3);
// Really dont need to include rest of the checks - covered by other tests - nothing to do with add
var registrations = index.ToList();
CollectionAssert.AllItemsAreNotNull(registrations);
CollectionAssert.AllItemsAreUnique(registrations);
CollectionAssert.Contains(registrations, reg1);
CollectionAssert.Contains(registrations, reg2);
CollectionAssert.Contains(registrations, reg3);
var out1 = index.Get(typeof(IFoo));
var out2 = index.Get(typeof(IBar));
var out3 = index.Get(typeof(IBar), "Key");
Assert.AreSame(out1, reg1);
Assert.AreSame(out2, reg2);
Assert.AreSame(out3, reg3);
}
}
public void TryGetReturnTheExpectedRegistration()
{
var reg1 = new InstanceRegistration <IFoo>(new Foo1());
var reg2 = new InstanceRegistration <IFoo>(new Foo1(), "Key1");
var reg3 = new InstanceRegistration <IFoo>(new Foo1(), "Key2");
var reg4 = new InstanceRegistration <IBar>(new Bar1(), "Key1");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
index.Add(reg3);
index.Add(reg4);
IRegistration out1;
var result1 = index.TryGet(typeof(IFoo), out out1);
IRegistration out2;
var result2 = index.TryGet(typeof(IFoo), "Key2", out out2);
Assert.IsTrue(result1);
Assert.IsTrue(result2);
Assert.IsInstanceOfType(out1, typeof(IRegistration));
Assert.IsInstanceOfType(out2, typeof(IRegistration));
Assert.AreSame(reg1, out1);
Assert.AreSame(reg3, out2);
}
}
public void ShouldSetLifetime()
{
// Given, When
var registration = new InstanceRegistration(typeof(IService), new ServiceOne());
// Then
Assert.Equal(RegistrationLifetime.Singleton, registration.Lifetime);
}
public override void Build(Container container)
{
var registration = new InstanceRegistration(container, this.instance, this.disposeWithContainer);
foreach (var serviceType in this.ServiceTypes)
{
container.AddRegistration(new TypeKey(serviceType.Type.TypeHandle, serviceType.Key), registration);
}
}
ResolutionPath CreateRegisteredNameResolutionPath(ResolutionPath parentPath, string name)
{
var registration = new InstanceRegistration(name)
{
Name = RegisteredName,
ServiceType = typeof(string),
};
return(parentPath.CreateChild(registration));
}
void SelfRegisterTheRegistry()
{
var registration = new InstanceRegistration(this)
{
DisposeWithContainer = false,
ServiceType = typeof(IReceivesRegistrations),
};
Registry.Add(registration);
}
/// <inheritdoc />
IUnityContainer IUnityContainer.RegisterInstance(Type?type, string?name, object?instance, IInstanceLifetimeManager?lifetimeManager)
{
var mappedToType = instance?.GetType();
var registeredType = type ?? mappedToType;
// Validate input
if (null == registeredType)
{
throw new InvalidOperationException(
$"At least one of Type arguments '{nameof(type)}' or '{nameof(instance)}' must be not 'null'");
}
try
{
// Lifetime Manager
var manager = lifetimeManager as LifetimeManager ??
Context.InstanceLifetimeManager.CreateLifetimePolicy();
// Create registration and add to appropriate storage
var container = manager is SingletonLifetimeManager ? _root : this;
Debug.Assert(null != container);
// Register type
var registration = new InstanceRegistration(container, registeredType, name, instance, manager);
var previous = container.Register(registeredType, name, registration);
// Allow reference adjustment and disposal
if (null != previous && 0 == previous.Release() &&
previous.LifetimeManager is IDisposable disposable)
{
// Dispose replaced lifetime manager
container.LifetimeContainer.Remove(disposable);
disposable.Dispose();
}
// Check what strategies to run
registration.Processors = Context.InstancePipelineCache;
// Raise event
container.RegisteringInstance?.Invoke(this, new RegisterInstanceEventArgs(registeredType, instance, name, manager));
}
catch (Exception ex)
{
var parts = new List <string>();
if (null != name)
{
parts.Add($" '{name}'");
}
var message = $"Error in RegisterInstance<{registeredType?.Name}>({string.Join(", ", parts)})";
throw new InvalidOperationException(message, ex);
}
return(this);
}
public void ShouldSetInstance()
{
// Given
var instance = new ServiceOne();
// When
var registration = new InstanceRegistration(typeof(IService), instance);
// Then
Assert.Same(instance, registration.Instance);
}
public void ShouldSetServiceType()
{
// Given
var serviceType = typeof(IService);
// When
var registration = new InstanceRegistration(serviceType, new ServiceOne());
// Then
Assert.Equal(serviceType, registration.ServiceType);
}
public void Should_register_startup_task_instance_registrations_into_container()
{
var instanceRegistrations = new InstanceRegistration[] { };
var startupStub = A.Fake <IStartup>();
A.CallTo(() => startupStub.InstanceRegistrations).Returns(instanceRegistrations);
bootstrapper.OverriddenStartupTasks = new[] { startupStub };
bootstrapper.Initialise();
bootstrapper.InstanceRegistrations.ShouldBeSameAs(instanceRegistrations);
}
public void InstanceRegistrationWorksLikeExpected()
{
var container = new IocContainer();
var instance = new Foo1();
var reg = new InstanceRegistration<IFoo>(instance);
Assert.AreEqual(reg.ReturnType, typeof(IFoo));
var out1 = reg.GetInstance();
Assert.AreSame(instance, out1);
}
public void InstanceRegistrationWorksLikeExpected()
{
var container = new IocContainer();
var instance = new Foo1();
var reg = new InstanceRegistration <IFoo>(instance);
Assert.AreEqual(reg.ReturnType, typeof(IFoo));
var out1 = reg.GetInstance();
Assert.AreSame(instance, out1);
}
private InstanceRegistrationOptions ProcessRegisterInstance(Type type, string name, object instance)
{
this.CheckRegistered(type, name);
var registration = new InstanceRegistration(type, name, instance);
var registrationOptions = new InstanceRegistrationOptions(registration);
this.AddRegistration(type, name, registration);
this.RaiseRegistered(registration);
return(registrationOptions);
}
/// <summary>
/// Registers a component instance. In this case the container will not create the instance dynamically, it will
/// simply use the instance provided.
/// </summary>
/// <returns>A builder instance.</returns>
/// <param name="instance">The created component instance.</param>
/// <typeparam name="T">The implementation type of the component to be registered, typically inferred from the provided instance.</typeparam>
public IAsBuilder RegisterInstance <T>(T instance) where T : class
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
var registration = new InstanceRegistration(instance)
{
ServiceType = typeof(T)
};
registrations.Add(registration);
return(new RegistrationBuilder(registration));
}
public void Set_OnResolved()
{
var registration = new InstanceRegistration(typeof(Item), "item", new Item());
var service = Activator.CreateInstance(typeof(InstanceRegistrationOptions),
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] { registration }, null) as InstanceRegistrationOptions;
Assert.AreEqual(null, registration.OnResolved);
var action = new Action <ContainerRegistration, object>((c, p) => { });
service.OnResolved(action);
Assert.AreEqual(action, registration.OnResolved);
}
public void Should_register_application_registration_instance_registrations_into_container()
{
// Given
var instanceRegistrations = new InstanceRegistration[] { };
var startupStub = A.Fake <IApplicationRegistrations>();
A.CallTo(() => startupStub.InstanceRegistrations).Returns(instanceRegistrations);
this.bootstrapper.OverriddenApplicationRegistrationTasks = new[] { startupStub };
// When
this.bootstrapper.Initialise();
// Then
this.bootstrapper.InstanceRegistrations.ShouldBeSameAs(instanceRegistrations);
}
public void TryGetAllThrowsExceptionIfTypeIsNotRegistered()
{
var reg1 = new InstanceRegistration<IFoo>(new Foo1());
var reg2 = new InstanceRegistration<IFoo>(new Foo1(), "Key");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
var result = index.TryGetAll(typeof(IBar));
// Assert
Assert.IsInstanceOfType(result, typeof(IEnumerable<IRegistration>));
Assert.IsTrue(result.Count() == 0);
}
}
public void TryGetAllGenericThrowsExceptionIfTypeIsNotRegistered()
{
var reg1 = new InstanceRegistration <IFoo>(new Foo1());
var reg2 = new InstanceRegistration <IFoo>(new Foo1(), "Key");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
var result = index.TryGetAll <IBar>();
// Assert
Assert.IsInstanceOfType(result, typeof(IEnumerable <IRegistration>));
Assert.IsTrue(result.Count() == 0);
}
}
void SelfRegisterAResolver()
{
var resolverRegistration = new InstanceRegistration(this)
{
DisposeWithContainer = false,
ServiceType = typeof(IResolvesServices),
};
Registry.Add(resolverRegistration);
var containerRegistration = new InstanceRegistration(this)
{
DisposeWithContainer = false,
ServiceType = typeof(IContainer),
};
Registry.Add(containerRegistration);
}
/// <summary>Converts a value. </summary>
/// <param name="value">The value produced by the binding source.</param>
/// <param name="targetType">The type of the binding target property.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
/// <returns>
/// A converted value. If the method returns <see langword="null" />,
/// the valid null value is used.
/// </returns>
public object Convert(
object value
, Type targetType
, object parameter
, CultureInfo culture
)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
var componentRegistration = ( IComponentRegistration )value;
var instanceInfo =
_provider.GetInstanceByComponentRegistration(componentRegistration);
var x = instanceInfo.Select(
(o, i) => {
var objId =
_provider.ProvideObjectInstanceIdentifier(
o.Instance
, componentRegistration
, o
.Parameters
);
var instanceRegistration =
new InstanceRegistration(
o.Instance
, objId
, o
);
return(instanceRegistration);
}
);
if (parameter is string xx)
{
if (string.CompareOrdinal(xx, "Count") == 0)
{
return(_provider.GetInstanceCount(componentRegistration));
}
}
return(x.AsList( ));
}
public void AddUsingKeyThrowsExceptionWhenDuplicatesAreRegistered()
{
var reg1 = new InstanceRegistration <IFoo>(new Foo1(), "Key");
var reg2 = new InstanceRegistration <IFoo>(new Foo1(), "Key");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
try
{
index.Add(reg2);
Assert.IsTrue(false);
}
catch (ArgumentException)
{
}
}
}
public void AddUsingKeyThrowsExceptionWhenDuplicatesAreRegistered()
{
var reg1 = new InstanceRegistration<IFoo>(new Foo1(), "Key");
var reg2 = new InstanceRegistration<IFoo>(new Foo1(), "Key");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
try
{
index.Add(reg2);
Assert.IsTrue(false);
}
catch (ArgumentException)
{
}
}
}
/// <summary>
/// Register an instance with the container.
/// </summary>
/// <remarks> <para>
/// Instance registration is much like setting a type as a singleton, except that instead
/// of the container creating the instance the first time it is requested, the user
/// creates the instance ahead of type and adds that instance to the container.
/// </para></remarks>
/// <param name="registrationType">Type of instance to register (may be an implemented interface instead of the full type).</param>
/// <param name="instance">Object to be returned.</param>
/// <param name="registrationName">Name for registration.</param>
/// <param name="lifetimeManager">
/// <para>If null or <see cref="ContainerControlledLifetimeManager"/>, the container will take over the lifetime of the instance,
/// calling Dispose on it (if it's <see cref="IDisposable"/>) when the container is Disposed.</para>
/// <para>
/// If <see cref="ExternallyControlledLifetimeManager"/>, container will not maintain a strong reference to <paramref name="instance"/>.
/// User is responsible for disposing instance, and for keeping the instance typeFrom being garbage collected.</para></param>
/// <returns>The <see cref="UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns>
public IUnityContainer RegisterInstance(Type registrationType, string registrationName, object instance, LifetimeManager lifetimeManager)
{
var registration = new InstanceRegistration(registrationType, registrationName, instance, lifetimeManager);
if (registration.LifetimeManager is IDisposable manager)
{
_lifetimeContainer.Add(manager);
}
var old = SetOrUpdate(registration.RegisteredType, registration.Name, registration);
if (old is IDisposable disposable)
{
_lifetimeContainer.Remove(disposable);
disposable.Dispose();
}
RegisteringInstance?.Invoke(this, new RegisterInstanceEventArgs(registrationType, instance, registrationName, lifetimeManager));
return(this);
}
string FormatRegistration(InstanceRegistration registration)
{
// Special case for the container itself
if (registration.ServiceType == typeof(IObjectContainer) && registration.Name == null)
{
return("<self>");
}
string implementationString;
try
{
implementationString = registration.Implementation.ToString();
}
catch (Exception ex)
{
implementationString = ex.Message;
}
return($"Instance: {implementationString}");
}
public void GetGenericReturnTheExpectedRegistration()
{
var reg1 = new InstanceRegistration<IFoo>(new Foo1());
var reg2 = new InstanceRegistration<IFoo>(new Foo1());
var reg3 = new InstanceRegistration<IFoo>(new Foo1());
var reg4 = new InstanceRegistration<IBar>(new Bar1());
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2, "Key1");
index.Add(reg3, "Key2");
index.Add(reg4, "Key1");
var out1 = index.Get<IFoo>();
var out2 = index.Get<IFoo>("Key2");
Assert.IsInstanceOfType(out1, typeof(IRegistration));
Assert.IsInstanceOfType(out2, typeof(IRegistration));
Assert.AreSame(reg1, out1);
Assert.AreSame(reg3, out2);
}
}
public void IndexIsEnumerable()
{
var reg1 = new InstanceRegistration<IFoo>(new Foo1());
var reg2 = new InstanceRegistration<IBar>(new Bar1());
var reg3 = new InstanceRegistration<IBar>(new Bar1());
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
index.Add(reg3, "Key");
Assert.IsTrue(index.Count() == 3);
var registrations = index.ToList();
CollectionAssert.AllItemsAreNotNull(registrations);
CollectionAssert.AllItemsAreUnique(registrations);
CollectionAssert.Contains(registrations, reg1);
CollectionAssert.Contains(registrations, reg2);
CollectionAssert.Contains(registrations, reg3);
}
}
public void IndexIsEnumerable()
{
var reg1 = new InstanceRegistration <IFoo>(new Foo1());
var reg2 = new InstanceRegistration <IBar>(new Bar1());
var reg3 = new InstanceRegistration <IBar>(new Bar1(), "Key");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
index.Add(reg3);
Assert.IsTrue(index.Count() == 3);
var registrations = index.ToList();
CollectionAssert.AllItemsAreNotNull(registrations);
CollectionAssert.AllItemsAreUnique(registrations);
CollectionAssert.Contains(registrations, reg1);
CollectionAssert.Contains(registrations, reg2);
CollectionAssert.Contains(registrations, reg3);
}
}
public void GetGenericReturnTheExpectedRegistration()
{
var reg1 = new InstanceRegistration <IFoo>(new Foo1());
var reg2 = new InstanceRegistration <IFoo>(new Foo1(), "Key1");
var reg3 = new InstanceRegistration <IFoo>(new Foo1(), "Key2");
var reg4 = new InstanceRegistration <IBar>(new Bar1(), "Key1");
foreach (var index in Helper.GetIndexes())
{
index.Add(reg1);
index.Add(reg2);
index.Add(reg3);
index.Add(reg4);
var out1 = index.Get <IFoo>();
var out2 = index.Get <IFoo>("Key2");
Assert.IsInstanceOfType(out1, typeof(IRegistration));
Assert.IsInstanceOfType(out2, typeof(IRegistration));
Assert.AreSame(reg1, out1);
Assert.AreSame(reg3, out2);
}
}
public static ConstraintDsl <Apply> For <TController>() where TController : Controller
{
var registration = new InstanceRegistration(new ControllerTypeConstraint <TController>(), EmptyActionDescriptor.Instance, new ReflectedControllerDescriptor(typeof(TController)), FilterScope.Controller);
return(CreateDsl(registration));
}
internal InstanceRegistrationOptions(InstanceRegistration registration)
{
this.registration = registration;
}
protected abstract void Register(TContainer container, InstanceRegistration registration);
public IDependencyContainer RegisterInstance(Type type, object instance, string key)
{
IRegistration registration = new InstanceRegistration(instance);
return(AddRegistration(type, key, registration));
}
public void Register(InstanceRegistration registration)
{
Initialize();
Register(_container, registration);
}
protected override void Register(TinyIoCContainer container, InstanceRegistration registration)
{
container.Register(registration.RegistrationType, registration.Instance);
}
public void InstanceRegistrationThrowsExceptionIfInstanceIsNull()
{
var reg = new InstanceRegistration <IFoo>(null);
}
public void ShouldIncludeAllProperties()
{
// Given
var registration = new InstanceRegistration(typeof(IService), new ServiceOne());
// When
var actual = registration.ToString();
// Then
Assert.Equal("Singleton - IService - Ministro.Test.ServiceOne", actual);
}
public void InstanceRegistrationThrowsExceptionIfInstanceIsNull()
{
var reg = new InstanceRegistration<IFoo>(null);
}
