public HomeController(IInjectionContainer ioc)
{
_class1 = ioc.Resolve <IClass1>();
_class2 = ioc.Resolve <IClass2>();
_class3 = ioc.Resolve <IClass3>();
_thing = ioc.Resolve <IClass1>("thing");
}
/// <summary>
/// Pools a command of a given type.
/// </summary>
/// <param name="commandType">Command type.</param>
public void PoolCommand(Type commandType)
{
var command = (ICommand)container.Resolve(commandType);
if (this.commands.ContainsKey(commandType))
{
return;
}
if (command.singleton)
{
this.commands.Add(commandType, command);
}
else
{
var commandPool = new List <ICommand>(command.preloadPoolSize);
// Add the currently resolved command.
commandPool.Add(command);
// Add other commands until matches preloadPoolSize.
if (command.preloadPoolSize > 1)
{
for (int itemIndex = 1; itemIndex < command.preloadPoolSize; itemIndex++)
{
commandPool.Add((ICommand)container.Resolve(commandType));
}
}
this.commands.Add(commandType, commandPool);
}
}
public async Task TimeWatchInterceptorTestV1()
{
//Configuration
var count = 0;
TraceData[] traceReceived = { };
_container.RegisterInterceptor(PredefinedInterceptors.TimeWatchInterceptor, LifeTime.Singleton);
_container.Intercept <IClassVoidTest>().With(PredefinedInterceptors.TimeWatchInterceptor);
var instance = _container.Resolve <IClassVoidTest>();
using (var tracer = new TraceSourceSync(_traceConfig))
{
tracer.OnTracesSent += trace =>
{
traceReceived = trace;
Interlocked.Increment(ref count);
};
//Test
instance.MethodCall();
//Verify
await tracer.FlushAndCompleteAddingAsync().ConfigureAwait(false);
}
// un seul retour
Assert.AreEqual(1, count);
Assert.AreEqual(1, traceReceived.Length);
Assert.IsTrue(traceReceived[0].Message.StartsWith("TIME_IClassVoidTest.MethodCall = "));
}
/// <summary>
/// Configures the host with the given baseurl and port.
/// </summary>
public static ICrowHttpHost ConfigureHost(IInjectionContainer container, string baseUrl, int port, bool isHttps = false)
{
var host = container.Resolve<ICrowHttpHost>();
var configuration = container.Resolve<IHostConfiguration>();
configuration.BaseUrl = baseUrl;
configuration.IsHttps = isHttps;
configuration.Port = port;
host.Configure(configuration);
return host;
}
public override void Execute(params object[] parameters)
{
var prefab = container.Resolve <Transform>();
// Tag the command so it can be released later.
this.dispatcher.Dispatch <RotateGameObjectCommand>(prefab).Tag(GameRoot.ROTATOR_COMMAND_TAG);
}
public BusinessControllerBase SelectBusinessController(HttpRequestMessage request, ITypeListHost host, INamingConvention convention, IInjectionContainer container)
{
UrlParser url = new UrlParser(request.RequestUri.ToString());
Type controllerType = host.BusinessTypeList[url.BusinessClass];
var instance = container.Resolve(controllerType);
return new CrowBusinessController(instance, url, convention);
}
public object GetService(Type serviceType)
{
if (typeof(IController).IsAssignableFrom(serviceType))
{
return(_container.Resolve(serviceType));
}
try
{
return(_container.Resolve(serviceType));
}
catch (ResolutionFailedException rex)
{
return(null);
}
}
/// <summary>
/// Configures the host with default configuration.
/// Port: 80 and baseurl : localhost
/// </summary>
public static ICrowHttpHost ConfigureHost(IInjectionContainer container)
{
var configuration = container.Resolve<IConfigurationHelper>();
var port = configuration.Get(Strings.Configuration.HostingPort, Strings.Defaults.DefaultPort);
var host = configuration.Get(Strings.Configuration.HostingHostname, Strings.Defaults.DefaultHostname);
var isHttps = configuration.Get(Strings.Configuration.HostingIsHttps, false);
return ConfigureHost(container, host, port, isHttps);
}
/// <summary>
/// Configures the host with default port 80.
/// </summary>
public static ICrowHttpHost ConfigureHost(IInjectionContainer container, string baseUrl)
{
var configuration = container.Resolve<IConfigurationHelper>();
var port = configuration.Get<int>(Strings.Configuration.HostingPort, Strings.Defaults.DefaultPort);
var host = baseUrl;
var isHttps = configuration.Get<bool>(Strings.Configuration.HostingIsHttps, false);
return ConfigureHost(container, host, port, isHttps);
}
/// <summary>
/// Setups bindings in the container.
/// </summary>
/// <param name="container">Container in which the bindings will be setup.</param>
/// <param name="type">The bindings setup object type.</param>
/// <returns>The injection container for chaining.</returns>
public static IInjectionContainer SetupBindings(this IInjectionContainer container, Type type)
{
var setup = container.Resolve(type);
container.SetupBindings((IBindingsSetup)setup);
return(container);
}
public override void Execute(params object[] parameters)
{
for (var cubeIndex = 0; cubeIndex < 36; cubeIndex++)
{
var cube = container.Resolve <GameObject>();
cube.name = string.Format("Cube {0:00}", cubeIndex);
}
}
/// <summary>
/// 为容器实例化一个 ICommandPool（CommandDispatcher）实例，并将容器内的所有 commands 实例化、
/// 注入并存入对象池（储存为 List<ICommand> 并根据类型添加到 CommandDispatcher 的字典中）
/// </summary>
public static IInjectionContainer PoolCommands(this IInjectionContainer container)
{
var commandPool = container.Resolve <ICommandPool>();
commandPool.Pool();
return(container);
}
public void OnRegister(IInjectionContainer container)
{
//Binds the command dispatcher to a singleton, so every command can
//receive the instance.
container.Bind<ICommandDispatcher>().ToSingleton<CommandDispatcher>();
//Binds the command pool to the CommandDispatcher.
var dispatcher = (CommandDispatcher)container.Resolve<ICommandDispatcher>();
container.Bind<ICommandPool>().To<CommandDispatcher>(dispatcher);
}
public void OnRegister(IInjectionContainer container)
{
// Bind the command dispatcher to a singleton, so every command can receive the instance.
container.Bind <ICommandDispatcher>().ToSingleton <CommandDispatcher>();
// Bind the command pool to the CommandDispatcher.
var dispatcher = (CommandDispatcher)container.Resolve <ICommandDispatcher>();
container.Bind <ICommandPool>().To <CommandDispatcher>(dispatcher);
}
public void EmptyCollection()
{
//Configuration
_sut.Register <IHandlerClass, HandlerClass>(LifeTime.Singleton);
_sut.Register <IPluginClass, PluginClass1>(LifeTime.Singleton);
//Test
var res = _sut.Resolve <IHandlerClass>();
//Verify
Assert.AreEqual(0, res.Plugins.Count);
}
public override void Execute(params object[] parameters)
{
//Spawn 36 cubes in the scene.
//Cubes have been bound to the "GameObject" type.
for (var cubeIndex = 0; cubeIndex < 36; cubeIndex++)
{
var cube = container.Resolve <GameObject>();
cube.name = string.Format("Cube {0:00}", cubeIndex);
}
}
/// <summary>
/// 将容器中所有 ICommand 对象实例化并缓存到字典
/// </summary>
public void Pool()
{
// 获取所有执行过注入后的 ICommand 对象实例
var resolvedCommands = container.ResolveAll <ICommand>();
for (var i = 0; i < resolvedCommands.Length; i++)
{
// 获取类型和实例
var command = resolvedCommands[i];
var commandType = command.GetType();
// 如果字典中已经有了就直接进行下次循环
if (commands.ContainsKey(commandType))
{
continue;
}
// 如果是单例类型就直接进行添加
if (command.singleton)
{
commands.Add(commandType, command);
}
else
{
// 否则用 list 来作为对象池
var commandPool = new List <ICommand>(command.preloadPoolSize);
// 将当前元素添加到 list 中
commandPool.Add(command);
// 如果对象池初始化数量大于1就继续进行实例化并添加到 list
if (command.preloadPoolSize > 1)
{
for (int n = 1; n < command.preloadPoolSize; n++)
{
commandPool.Add((ICommand)container.Resolve(commandType));
}
}
// 将 list 添加到字典
commands.Add(commandType, commandPool);
}
}
}
/// <summary>
/// Register a command of type <paramref name="type"/>.
///
/// After all commands have been registered, call <code>PoolCommands()</code> to pool
/// all commands.
///
/// If <code>RegisterCommands()</code> is used, the commands are already pooled.
/// </summary>
/// <param name="container">The container in which the command will be registered.</param>
/// <param name="type">The type of the command to be registered.</param>
/// <returns>The injection container for chaining.</returns>
public static IInjectionContainer RegisterCommand(this IInjectionContainer container, Type type)
{
if (!type.IsClass && type.IsAssignableFrom(typeof(ICommand)))
{
throw new CommandException(CommandException.TYPE_NOT_A_COMMAND);
}
container.Bind <ICommand>().To(type);
container.Resolve <ICommandPool>().PoolCommand(type);
return(container);
}
public async Task InterceptionTestV1()
{
//Configuration
var count = 0;
TraceData[] traceReceived = { };
using (var tracer = new TraceSourceSync(new TraceConfig {
TraceBehavior = TraceStaticBehavior.AddListenerToStaticAccessAndRemoveDefaultTracer, PageSize = 2
}))
{
_container.RegisterInstance(tracer);
_container.RegisterInterceptor <InterceptorTraceInjectTracer>(LifeTime.Singleton);
_container.RegisterInterceptor <InterceptorTraceStatic>(LifeTime.Singleton);
_container.Register <IClassVoidTest, ClassVoidTest>(LifeTime.Singleton);
_container.Intercept <IClassVoidTest>().With <InterceptorTraceInjectTracer>();
_container.Intercept <IClassVoidTest>().With <InterceptorTraceStatic>();
tracer.OnTracesSent += trace =>
{
traceReceived = trace;
Interlocked.Increment(ref count);
};
//Test
var instance = _container.Resolve <IClassVoidTest>();
instance.MethodCall();
//Verify
await tracer.FlushAndCompleteAddingAsync().ConfigureAwait(false);
}
// un seul retour (avec les deux traces des intercepteurs)
Assert.AreEqual(1, count);
Assert.IsNotNull(traceReceived.Single(o => o.Message == "IClassVoidTest_InterceptorTraceInjectTracer"));
Assert.IsNotNull(traceReceived.Single(o => o.Message == "IClassVoidTest_InterceptorTraceStatic"));
}
public void OnRegister(IInjectionContainer container)
{
this.CreateBehaviour(container.identifier);
// Check whether a binding for the ICommandDispatcher exists.
if (container.ContainsBindingFor <ICommandDispatcher>())
{
var dispatcher = container.Resolve <ICommandDispatcher>();
BindUnityExtension(disposable, dispatcher);
}
container.afterAddBinding += this.OnAfterAddBinding;
container.bindingResolution += this.OnBindingResolution;
}
public void OnRegister(IInjectionContainer container)
{
//Adds the container to the disposable list.
disposable.Add(container);
//Checks whether a binding for the ICommandDispatcher exists.
if (container.ContainsBindingFor<ICommandDispatcher>()) {
var dispatcher = container.Resolve<ICommandDispatcher>();
if (dispatcher is IDisposable) {
disposable.Add((IDisposable)dispatcher);
}
}
container.afterAddBinding += this.OnAfterAddBinding;
container.bindingResolution += this.OnBindingResolution;
}
/// <summary>
/// 为指定命名空间中实现了 IBindingsSetup 接口的类型在容器中实例化并注入，再按优先级排序，最后按
/// 顺序执行它们自身所实现的 SetupBindings 方法
/// </summary>
public static IInjectionContainer SetupBindings(this IInjectionContainer container,
string namespaceName,
bool includeChildren)
{
// 获取指定命名空间中实现了 IBindingsSetup 接口的类型数组
var setups = TypeUtils.GetAssignableTypes(
typeof(IBindingsSetup), namespaceName, includeChildren);
// 新建一个和获取到的类型数组同等长度的内部类数组
var prioritizedSetups = new PrioritizedSetup[setups.Length];
for (var i = 0; i < setups.Length; i++)
{
// 使用指定容器获取类型的经过注入后的类型实例
var setup = (IBindingsSetup)container.Resolve(setups[i]);
var attributes = setup.GetType().GetCustomAttributes(typeof(Priority), true);
// 如果获取到了[Priority]特性，就将类型的实例和其优先级数字新建为一个新的内部类加入数组
if (attributes.Length > 0)
{
var bindingPriority = attributes[0] as Priority;
prioritizedSetups[i] = new PrioritizedSetup()
{
setup = setup,
priority = bindingPriority.priority
};
}
else
{
// 如果没有获取到，就用实例和优先级数字0来新建一个内部类加入数组
prioritizedSetups[i] = new PrioritizedSetup()
{
setup = setup,
priority = 0
};
}
}
// 对数组进行排序
Array.Sort(prioritizedSetups);
// 逐一执行 setup 对象所实现的 SetupBindings 方法
for (var setupIndex = 0; setupIndex < prioritizedSetups.Length; setupIndex++)
{
prioritizedSetups[setupIndex].setup.SetupBindings(container);
}
return(container);
}
public void OnRegister(IInjectionContainer container)
{
//Adds the container to the disposable list.
disposable.Add(container);
//Checks whether a binding for the ICommandDispatcher exists.
if (container.ContainsBindingFor <ICommandDispatcher>())
{
var dispatcher = container.Resolve <ICommandDispatcher>();
if (dispatcher is IDisposable)
{
disposable.Add((IDisposable)dispatcher);
}
}
container.afterAddBinding += this.OnAfterAddBinding;
container.bindingResolution += this.OnBindingResolution;
}
/// <summary>
/// Register all commands from a given namespace.
/// </summary>
/// <param name="container">The container in which the command will be registered.</param>
/// <param name="includeChildren">Indicates whether child namespaces should be included.</param>
/// <param name="namespaceName">Namespace name.</param>
/// <returns>The injection container for chaining.</returns>
public static IInjectionContainer RegisterCommands(this IInjectionContainer container,
string namespaceName,
bool includeChildren)
{
var commands = TypeUtils.GetAssignableTypes(typeof(ICommand), namespaceName, includeChildren);
if (commands.Length > 0)
{
var pool = container.Resolve <ICommandPool>();
for (var cmdIndex = 0; cmdIndex < commands.Length; cmdIndex++)
{
pool.AddCommand(commands[cmdIndex]);
}
}
return(container);
}
public static RouteBase MapBusiness(this RouteCollection routes, string url, IInjectionContainer container)
{
INamingConvention convention = container.Resolve<INamingConvention>();
BusinessInvoker invoker = new BusinessInvoker(AspNetRoutedHost.HostList, convention, container);
string routeUrl = url;
if (!routeUrl.EndsWith("/"))
{
routeUrl += "/{*operation}";
}
routeUrl = routeUrl.TrimStart('~').TrimStart('/');
var route = new Route(routeUrl, new CrowRouteHandler(invoker));
routes.Add("Crow", route);
return route;
}
/// <summary>
/// Setups bindings in the container from a given <paramref name="namespace"/>.
/// </summary>
/// <param name="container">Container in which the bindings will be setup.</param>
/// <param name="namespaceName">Namespace name.</param>
/// <param name="includeChildren">Indicates whether child namespaces should be included.</param>
/// <param name="setup">The bindings setup.</param>
/// <returns>The injection container for chaining.</returns>
public static IInjectionContainer SetupBindings(this IInjectionContainer container,
string namespaceName,
bool includeChildren)
{
var setups = TypeUtils.GetAssignableTypes(
typeof(IBindingsSetup), namespaceName, includeChildren);
var prioritizedSetups = new PrioritizedBindingSetup[setups.Length];
//Adds setups to "priority" with priority definitions.
for (var setupIndex = 0; setupIndex < setups.Length; setupIndex++)
{
var setup = (IBindingsSetup)container.Resolve(setups[setupIndex]);
var attributes = setup.GetType().GetCustomAttributes(typeof(BindingPriority), true);
if (attributes.Length > 0)
{
var bindindPriority = attributes[0] as BindingPriority;
prioritizedSetups[setupIndex] = new PrioritizedBindingSetup()
{
setup = setup,
priority = bindindPriority.priority
};
}
else
{
//If the binding has no priority, saves it with priority 0.
prioritizedSetups[setupIndex] = new PrioritizedBindingSetup()
{
setup = setup,
priority = 0
};
}
}
//Orders the priority list and executes the setups.
prioritizedSetups = prioritizedSetups.OrderByDescending(setup => setup.priority).ToArray();
for (var setupIndex = 0; setupIndex < prioritizedSetups.Length; setupIndex++)
{
prioritizedSetups[setupIndex].setup.SetupBindings(container);
}
return(container);
}
public void PerformanceNewClassTestV2()
{
//Configuration
_container.Register <IClassVoidTest, ClassVoidTest>(LifeTime.Transient);
//Test
const int upper = 10_000;
var watch = Stopwatch.StartNew();
for (var i = 0; i < upper; i++)
{
var _ = _container.Resolve <IClassVoidTest>();
}
watch.Stop();
//Verify
Assert.IsTrue(watch.Elapsed < TimeSpan.FromSeconds(1),
$"Trop lent pour créer {upper} objet transient: time = {watch.ElapsedMilliseconds} ms");
}
/// <summary>
/// Pools all commands.
/// </summary>
public void Pool()
{
var resolvedCommands = container.ResolveAll <ICommand>();
for (var cmdIndex = 0; cmdIndex < resolvedCommands.Length; cmdIndex++)
{
var command = resolvedCommands[cmdIndex];
var commandType = command.GetType();
//If the type already exists in the pool, goes to the next type.
if (this.commands.ContainsKey(commandType))
{
continue;
}
if (command.singleton)
{
this.commands.Add(commandType, command);
}
else
{
var commandPool = new List <ICommand>(command.preloadPoolSize);
//Adds the currently resolved command.
commandPool.Add(command);
//Adds other commands until matches preloadPoolSize.
if (command.preloadPoolSize > 1)
{
for (int itemIndex = 1; itemIndex < command.preloadPoolSize; itemIndex++)
{
commandPool.Add((ICommand)container.Resolve(commandType));
}
}
this.commands.Add(commandType, commandPool);
}
}
}
/// <summary>
/// 注册容器
/// </summary>
public void OnRegister(IInjectionContainer container)
{
// 将容器添加到 IDisposable list.
disposable.Add(container);
// 如果容器中含有 ICommandDispatcher 类型的 binding，且它实现了 IDisposable 接口
// 就获取它的 ICommandDispatcher 类型实例并将其也添加到 IDisposable list
var commandDispatches = container.GetTypes <ICommandDispatcher>();
if (commandDispatches != null && commandDispatches.Count != 0)
{
var dispatcher = container.Resolve <ICommandDispatcher>();
if (dispatcher is IDisposable)
{
disposable.Add((IDisposable)dispatcher);
}
}
// 添加 AOT 委托
container.afterAddBinding += this.OnAfterAddBinding;
container.afterInstantiate += this.OnBindingResolution;
}
/// <summary>
/// Register all commands from a given namespace.
///
/// After registration, all commands are pooled.
/// </summary>
/// <param name="container">The container in which the command will be registered.</param>
/// <param name="includeChildren">Indicates whether child namespaces should be included.</param>
/// <param name="namespaceName">Namespace name.</param>
/// <returns>The injection container for chaining.</returns>
public static IInjectionContainer RegisterCommands(this IInjectionContainer container,
string namespaceName,
bool includeChildren)
{
var commands = TypeUtils.GetAssignableTypes(typeof(ICommand), namespaceName, includeChildren);
if (commands.Length > 0)
{
var commandPool = container.Resolve <ICommandPool>();
for (var cmdIndex = 0; cmdIndex < commands.Length; cmdIndex++)
{
var commandType = commands[cmdIndex];
if (!commandType.IsAbstract)
{
container.Bind <ICommand>().To(commandType);
commandPool.PoolCommand(commandType);
}
}
}
return(container);
}
public void Init(IInjectionContainer container)
{
container.Resolve <ICommandDispatcher>().Init();
}
/// <summary>
/// Gets the command dispatcher in the container.
/// </summary>
/// <param name="container">The container in which the command is registered.</param>
/// <returns>The command dispatcher.</returns>
public static ICommandDispatcher GetCommandDispatcher(this IInjectionContainer container)
{
return(container.Resolve <ICommandDispatcher>());
}
/// <summary>
/// Register a command of type <paramref name="type"/>.
/// </summary>
/// <param name="container">The container in which the command will be registered.</param>
/// <param name="type">The type of the command to be registered.</param>
/// <returns>The injection container for chaining.</returns>
public static IInjectionContainer RegisterCommand(this IInjectionContainer container, Type type)
{
container.Resolve <ICommandPool>().AddCommand(type);
return(container);
}
public override void Execute(params object[] parameters)
{
var prefab = container.Resolve <Transform>();
this.dispatcher.Dispatch <RotateGameObjectCommand>(prefab);
}
public async Task MethodInterceptorTestV1()
{
//Configuration
var count = 0;
TraceData[] traceReceived = { };
_container.RegisterInterceptor(PredefinedInterceptors.MethodTraceInterceptor, LifeTime.Singleton);
_container.Intercept <IClassVoidTest>().With(PredefinedInterceptors.MethodTraceInterceptor);
var instance = _container.Resolve <IClassVoidTest>();
using (var tracer = new TraceSourceSync(_traceConfig))
{
tracer.OnTracesSent += trace =>
{
traceReceived = trace;
Interlocked.Increment(ref count);
};
//Test
instance.MethodCall();
//Verify
await tracer.FlushAndCompleteAddingAsync().ConfigureAwait(false);
}
// un seul retour (avec les deux traces des intercepteurs)
Assert.AreEqual(1, count);
Assert.AreEqual(2, traceReceived.Length);
Assert.AreEqual("START_IClassVoidTest.MethodCall()", traceReceived[0].Message);
Assert.AreEqual("STOP_IClassVoidTest.MethodCall", traceReceived[1].Message);
}
public GenericManager(IInjectionContainer ioc)
{
_class1 = ioc.Resolve <IClass1>();
_class2 = ioc.Resolve <IClass2>();
_class3 = ioc.Resolve <IClass3>();
}
