/// <summary>
/// Creates the injector class.
/// </summary>
/// <param name="typeInformationManager">The type information manager</param>
/// <param name="objectCreationManager">The object creation manager</param>
/// <param name="singletonCache">The cache for singletons</param>
/// <param name="scannedTypeManager">The scanned type manager</param>
protected internal Injector(TypeInformationManager typeInformationManager, FactoryManager objectCreationManager, SingletonCache singletonCache, ScannedTypeManager scannedTypeManager)
{
if (typeInformationManager == null)
{
throw new ArgumentNullException(nameof(typeInformationManager));
}
if (objectCreationManager == null)
{
throw new ArgumentNullException(nameof(objectCreationManager));
}
if (singletonCache == null)
{
throw new ArgumentNullException(nameof(singletonCache));
}
if (scannedTypeManager == null)
{
throw new ArgumentNullException(nameof(scannedTypeManager));
}
registrations = new ConcurrentDictionary <Type, Dictionary <string, ContainerRegistration> >();
registered = new List <EventHandler <RegistrationEventArgs> >();
resolved = new List <EventHandler <ResolutionEventArgs> >();
this.lifetimeOnDiscovery = LifetimeOnDiscovery.Transcient;
this.typeInformationManager = typeInformationManager;
this.objectCreationManager = objectCreationManager;
this.singletonCache = singletonCache;
this.scannedTypeManager = scannedTypeManager;
this.autoDiscovery = true;
}
public void UnregisterInstance()
{
var t = new TypeInformationManager();
var o = new FactoryManager();
var c = new SingletonCache();
var injector = Activator.CreateInstance(typeof(Injector),
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] { t, o, c, new ScannedTypeManager() }, null)
as Injector;
var item2 = new Item {
myString = "with k1"
};
injector.RegisterType(typeof(Item));
injector.RegisterInstance(typeof(Item), "k1", item2);
Assert.IsTrue(injector.IsRegistered <Item>());
Assert.IsTrue(injector.IsRegistered <Item>("k1"));
Assert.IsTrue(injector.Unregister <Item>());
Assert.IsFalse(injector.IsRegistered <Item>());
Assert.IsTrue(injector.IsRegistered <Item>("k1"));
Assert.IsTrue(injector.Unregister <Item>("k1"));
Assert.IsFalse(injector.IsRegistered <Item>("k1"));
}
public void GetConstructor_Get_Empty_Ctor_Not_Ordered()
{
var m = new TypeInformationManager();
var ctor1 = m.GetConstructor(typeof(ItemWithMultiCtor), true);
Assert.AreEqual(0, ctor1.GetParameters().Length);
}
public void GetConstructor_Get_Preferred_Ctor()
{
var m = new TypeInformationManager();
var ctor1 = m.GetConstructor(typeof(ItemWithPreferredCtor), true);
Assert.AreEqual(1, ctor1.GetParameters().Length);
Assert.AreEqual(typeof(int), ctor1.GetParameters()[0].ParameterType);
}
public void GetTypeInformation_Cache()
{
var m = new TypeInformationManager();
var t1 = m.GetTypeInformation(typeof(ItemWithPreferredCtor), true);
Assert.AreEqual(1, t1.Parameters.Length);
Assert.AreEqual(typeof(int), t1.Parameters[0].ParameterType);
Assert.IsNotNull(t1.Constructor);
Assert.AreEqual(1, m.TypeCache.Count);
}
public void GetConstructor_With_Public_And_Private_Ctor()
{
var m = new TypeInformationManager();
var ctor1 = m.GetConstructor(typeof(Item), true);
var ctor2 = m.GetConstructor(typeof(ItemWithPrivateCtor), false);
var ctor3 = m.GetConstructor(typeof(ItemWithPrivateCtor), true);
Assert.IsNotNull(ctor1);
Assert.IsNull(ctor2);
Assert.IsNotNull(ctor3);
}
public void Getproperties()
{
var m = new TypeInformationManager();
var p = m.GetPropertiesWithDependencyAttribute(typeof(ItemWithDependency), true);
Assert.AreEqual(2, p.Count);
Assert.AreEqual(null, p[0].Name);
Assert.AreEqual("MyString", p[0].Property.Name);
Assert.AreEqual("k1", p[1].Name);
Assert.AreEqual("MyItem", p[1].Property.Name);
Assert.AreEqual(1, m.PropertiesWithDependencyAttributeCache.Count);
}
public void UnregisterType()
{
var t = new TypeInformationManager();
var o = new FactoryManager();
var c = new SingletonCache();
var injector = Activator.CreateInstance(typeof(Injector),
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] { t, o, c, new ScannedTypeManager() }, null)
as Injector;
injector.RegisterSingleton <Item>();
Assert.IsTrue(injector.IsRegistered <Item>());
var instance = injector.GetInstance <Item>();
Assert.IsTrue(c.Cache.ContainsKey(typeof(Item)));
Assert.IsTrue(injector.Unregister <Item>());
Assert.IsFalse(injector.IsRegistered <Item>());
Assert.IsFalse(c.Cache.ContainsKey(typeof(Item)));
}
