protected virtual void RegisterObjectContainer()
{
IObjectContainerFactory factory = new ObjectContainerFactory();
var container = factory.CreateContainer(Server.MapPath("~/unity.config"));
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
//GlobalConfiguration.Configuration.ServiceResolver.SetResolver(new UnityDependencyResolver(container));
}
protected virtual void RegisterObjectContainer()
{
IObjectContainerFactory factory = new ObjectContainerFactory();
var container = factory.CreateContainer(Server.MapPath("~/unity.config"));
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
//GlobalConfiguration.Configuration.ServiceResolver.SetResolver(new UnityDependencyResolver(container));
}
/// <summary>
/// opens an
/// <see cref="Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
/// on the specified database file for local use.
/// <br />
/// <br />
/// A database file can only be opened once, subsequent attempts to
/// open another
/// <see cref="Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
/// against the same file will result in a
/// <see cref="Db4objects.Db4o.Ext.DatabaseFileLockedException"> DatabaseFileLockedException</see>
/// .
/// <br />
/// <br />
/// Database files can only be accessed for readwrite access from one
/// process at one time. All versions except for db4o mobile edition
/// use an internal mechanism to lock the database file for other
/// processes.
/// <br />
/// <br />
/// </summary>
/// <param name="config">
/// a custom
/// <see cref="Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
/// instance to be obtained via
/// <see cref="newConfiguration">newConfiguration</see>
/// </param>
/// <param name="databaseFileName">
/// an absolute or relative path to the database
/// file
/// </param>
/// <returns>
/// an open
/// <see cref="Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
/// </returns>
/// <seealso cref="Db4objects.Db4o.Config.IConfiguration.ReadOnly">
/// Db4objects.Db4o.Config.IConfiguration.ReadOnly
/// </seealso>
/// <seealso cref="Db4objects.Db4o.Config.IConfiguration.Encrypt">
/// Db4objects.Db4o.Config.IConfiguration.Encrypt
/// </seealso>
/// <seealso cref="Db4objects.Db4o.Config.IConfiguration.Password">
/// Db4objects.Db4o.Config.IConfiguration.Password
/// </seealso>
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException">
/// I/O operation failed or was unexpectedly
/// interrupted.
/// </exception>
/// <exception cref="Db4objects.Db4o.Ext.DatabaseFileLockedException">
/// the required database file is locked by
/// another process.
/// </exception>
/// <exception cref="Db4objects.Db4o.Ext.IncompatibleFileFormatException">
/// runtime
/// <see cref="Db4objects.Db4o.Config.IConfiguration">configuration</see>
/// is not compatible with the configuration of the database file.
/// </exception>
/// <exception cref="Db4objects.Db4o.Ext.OldFormatException">
/// open operation failed because the database file is in old format
/// and
/// <see cref="Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates">
/// Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates
/// </see>
/// is set to false.
/// </exception>
/// <exception cref="Db4objects.Db4o.Ext.DatabaseReadOnlyException">
/// database was configured as read-only.
/// </exception>
public static IEmbeddedObjectContainer OpenFile(IEmbeddedConfiguration config, string
databaseFileName)
{
if (null == config)
{
throw new ArgumentNullException();
}
return(ObjectContainerFactory.OpenObjectContainer(config, databaseFileName));
}
protected virtual IExecutionRule GetExecutionRule()
{
IObjectContainer objectContainer = ObjectContainerFactory.GetObjectContainer();
if (!objectContainer.IsRegistered(typeof(IExecutionRule)))
{
objectContainer.RegisterType <IExecutionRule, NullExecutionRule>(new object[0]);
}
return(objectContainer.Resolve <IExecutionRule>());
}
public virtual void EnvTest_IOC_TypeBySelf()
{
var container = ObjectContainerFactory.CreateContainer();
container.RegisterType <Dog, Dog>();
var instance = container.Resolve <Dog>();
Assert.AreEqual(instance.GetType(), typeof(Dog));
}
public virtual void EnvTest_IOC_TypeWithoutRegister()
{
var container = ObjectContainerFactory.CreateContainer();
var dog = container.Resolve <Dog>();
Assert.AreEqual(dog.GetType(), typeof(Dog));
var bigDog = container.Resolve <BigDog>();
Assert.AreEqual(bigDog.GetType(), typeof(BigDog));
}
/// <summary>
/// 后注册的项，可以覆盖前面注册的项。
/// </summary>
public virtual void EnvTest_IOC_Register_ReplaceByAfter()
{
var container = ObjectContainerFactory.CreateContainer();
container.RegisterType <Dog, Dog>();
container.RegisterType <Dog, BigDog>();
container.RegisterType <Dog, SmallDog>();
var instance = container.Resolve <Dog>();
Assert.AreEqual(instance.GetType(), typeof(SmallDog));
}
public virtual void EnvTest_IOC_Interface_RegisterByType()
{
var container = ObjectContainerFactory.CreateContainer();
container.RegisterInstance(typeof(IPlant), typeof(Tree));
var instance = container.Resolve <IPlant>();
Assert.IsTrue(instance is Tree);
var instance2 = container.Resolve <IPlant>();
Assert.IsTrue(instance == instance2);
}
public virtual void EnvTest_IOC_CtorNeedInterface()
{
var container = ObjectContainerFactory.CreateContainer();
var smallDog = container.Resolve <SmallDog>();
Assert.IsNotNull(smallDog.Parent);
var bigDog = new BigDog();
container.RegisterInstance(bigDog);
var smallDog2 = container.Resolve <SmallDog>();
Assert.AreEqual(bigDog, smallDog2.Parent);
}
/// <summary>
/// Create a new type adapter from currect factory
/// </summary>
/// <returns>Created type adapter</returns>
public static ITypeAdapter CreateAdapter()
{
if (_currentTypeAdapterFactory == null)
{
lock (lock_flag)
{
if (_currentTypeAdapterFactory == null)
{
_currentTypeAdapterFactory = ObjectContainerFactory.CreateContainer().Resolve <ITypeAdapterFactory>();
}
}
}
return(_currentTypeAdapterFactory.Create());
}
/// <summary>
/// 没有注册的接口是无法获取实例的。
/// </summary>
public virtual void EnvTest_IOC_Interface_ErrorWithoutRegister()
{
var container = ObjectContainerFactory.CreateContainer();
bool success = true;
try
{
container.Resolve <IAnimal>();
}
catch
{
success = false;
}
Assert.IsFalse(success);
}
/// <summary>
/// 实例依赖的接口还没有注册的话，是无法创建实例的。
/// </summary>
public virtual void EnvTest_IOC_Interface_RegisterByType_Dependency_Error()
{
var container = ObjectContainerFactory.CreateContainer();
container.RegisterInstance(typeof(IAnimal), typeof(Rabbit));
bool success = false;
try
{
var rabbit = container.Resolve <IAnimal>();
success = true;
}
catch { }
Assert.IsFalse(success);
}
/// <summary>
/// Rabbit 依赖 IPlant，但是一样可以获取到它之后注册的 Tree 实例。
/// </summary>
public virtual void EnvTest_IOC_Interface_RegisterByType_Dependency()
{
var container = ObjectContainerFactory.CreateContainer();
container.RegisterInstance(typeof(IAnimal), typeof(Rabbit));
container.RegisterInstance(typeof(IPlant), typeof(Tree));
var instance = container.Resolve <IAnimal>();
Assert.IsTrue(instance is Rabbit);
var rabbit = instance as Rabbit;
Assert.IsTrue(rabbit.Food is Tree);
}
public virtual void EnvTest_IOC_TypeByType()
{
var container = ObjectContainerFactory.CreateContainer();
container.RegisterType <Dog, BigDog>();
var instance = container.Resolve <Dog>();
Assert.IsTrue(instance is BigDog);
var smallDog = new SmallDog(instance as BigDog);
container.RegisterInstance <Dog>(smallDog);
instance = container.Resolve <Dog>();
Assert.IsTrue(instance == smallDog);
}
public virtual void EnvTest_IOC_Interface()
{
var container = ObjectContainerFactory.CreateContainer();
container.RegisterType <IAnimal, Dog>();
var instance = container.Resolve <IAnimal>();
Assert.IsTrue(instance is Dog);
var cat = new Cat();
container.RegisterInstance <IAnimal>(cat);
instance = container.Resolve <IAnimal>();
Assert.IsTrue(instance == cat);
}
/// <summary>
/// 启动所有的 实体插件
/// </summary>
internal static void StartupAppPlugins()
{
var libraries = GetAppPlugins();
foreach (var pluginAssembly in libraries)
{
//调用 ILibrary
var library = pluginAssembly.Instance as AppPlugin;
if (library != null)
{
library.Initialize(_appCore);
}
}
ObjectContainerFactory.SetProvider(new UnityContainerAdapterFactory());
Composer.RegisterAllPluginsByAttribute();
}
public static ICacheProvider GetCache(string key)
{
if (string.IsNullOrWhiteSpace(key))
{
return(instance);
}
if (!instances.ContainsKey(key))
{
lock (_cacheLock)
{
if (!instances.ContainsKey(key))
{
instances.Add(key, ObjectContainerFactory.CreateContainer().Resolve <ICacheProvider>(key));
}
}
}
return(instances[key]);
}
public virtual void EnvTest_IOC_ResolveAll()
{
var container = ObjectContainerFactory.CreateContainer();
container.RegisterType <IAnimal, Dog>();
container.RegisterType <IAnimal, BigDog>("BigDog");
container.RegisterType <IAnimal, SmallDog>("SmallDog");
container.RegisterInstance <IAnimal>(new Cat {
Name = "null"
});
container.RegisterInstance <IAnimal>(new Cat {
Name = "another"
}, "another");
var instances = container.ResolveAll <IAnimal>();
Assert.AreEqual(instances.Count(), 3);
Assert.IsTrue(instances.Any(i => i is BigDog));
Assert.IsTrue(instances.Any(i => i is SmallDog));
Assert.IsTrue(instances.Any(i => i is Cat));
Assert.IsTrue(instances.Any(i =>
{
var smallDog = i as SmallDog;
if (smallDog != null)
{
return(smallDog.Parent != null);
}
return(true);
}));
Assert.IsTrue(instances.Any(i =>
{
var cat = i as Cat;
if (cat != null)
{
return(cat.Name == "another");
}
return(true);
}));
}
public static IObjectContainer OpenFile(IConfiguration config, string databaseFileName
)
{
return(ObjectContainerFactory.OpenObjectContainer(Db4oLegacyConfigurationBridge.AsEmbeddedConfiguration
(config), databaseFileName));
}
/// <summary>
/// 插件的初始化方法。
/// </summary>
/// <param name="app">应用程序对象。</param>
public override void Initialize(IApp app)
{
ObjectContainerFactory.SetProvider(new UnityContainerAdapterFactory());
}
public RabbitMQBuilder RegisterObjectContainer(IObjectContainer objectContainer)
{
ObjectContainerFactory.RegisterContainer(objectContainer);
return(this);
}
