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>(); }