Contains information about a service registration.
Inheritance: IBinding
Esempio n. 1
0
		/// <summary>
		/// Attempts to handle a missing binding for a service.
		/// </summary>
		/// <param name="service">The service.</param>
		/// <returns><c>True</c> if the missing binding can be handled; otherwise <c>false</c>.</returns>
		protected override bool HandleMissingBinding(Type service)
		{
			var binding = new Binding(service)
			{
				ProviderCallback = MockProvider.GetCreationCallback(this),
				ScopeCallback = ctx => null,
				IsImplicit = true
			};

			AddBinding(binding);

			return true;
		}
        /// <summary>
        /// Returns any bindings from the specified collection that match the specified request.
        /// </summary>
        /// <param name="bindings">The multimap of all registered bindings.</param>
        /// <param name="request">The request in question.</param>
        /// <returns>The series of matching bindings.</returns>
        public IEnumerable<IBinding> Resolve(Multimap<Type, IBinding> bindings, IRequest request)
        {
            var service = request.Service;
            if (typeof(Controller).IsAssignableFrom(service))
            {
                var binding = new Binding(service) { ProviderCallback = StandardProvider.GetCreationCallback(service) };
                binding.Parameters.Add(
                    typeof(AsyncController).IsAssignableFrom(service)
                        ? new PropertyValue("ActionInvoker", ctx => ctx.Kernel.Get<NinjectAsyncActionInvoker>())
                        : new PropertyValue("ActionInvoker", ctx => ctx.Kernel.Get<NinjectActionInvoker>()));
                return new[] { binding };
            }

            return Enumerable.Empty<IBinding>();
        }
	    public void Handle(XmlModule module, XElement element)
		{
			XAttribute serviceAttribute = element.RequiredAttribute("service");

			Type service = GetTypeFromAttributeValue(serviceAttribute);

			var binding = new Binding(service);
			var builder = new BindingBuilder<object>(binding, _kernel);

			module.AddBinding(binding);

			if (!HandleTarget(element, builder))
				throw new ConfigurationErrorsException("The 'bind' element does not define either a 'to' or 'toProvider' attribute.");

			ReadName(element, builder);
			ReadMetadata(element, builder);
			ReadScope(element, builder);
		}
        private static void RegisterType(IKernel kernel, Type type, IEnumerable<INinjectRegistrationAttribute> attributes)
        {
            var builder = new BindingBuilder() as IBindingBuilder;

            foreach (INinjectRegistrationAttribute attribute in attributes)
            {
                builder = attribute.Register(builder);
            }

            foreach (var service in builder.Services)
            {
                var binding = new Binding(service);
                binding.BindingConfiguration.ScopeCallback = builder.ScopeCallback;
                binding.BindingConfiguration.ProviderCallback = StandardProvider.GetCreationCallback(type);
                binding.BindingConfiguration.Target = BindingTarget.Type;
                kernel.AddBinding(binding);
            }
        }
		/// <summary>
		/// 
		/// </summary>
		/// <param name="service"></param>
		/// <returns></returns>
		protected override bool HandleMissingBinding(Type service)
		{
			bool selfBindable = TypeIsSelfBindable(service);

			if (selfBindable)
				Bind(service).ToSelf().InSingletonScope();
			else
			{
				var binding = new Binding(service)
					{
						ProviderCallback = MockProvider.GetCreationCallback(),
						ScopeCallback = ctx => StaticScope, 
						IsImplicit = true
					};

				AddBinding(binding);
			}
			return true;
		}
Esempio n. 6
0
        internal LomsKernel() { }// The idea is that only the KernelContainer can create the Kernel (or for Tests we set the InternalsVisibleTo)

        /// <remarks>
        /// We use a convention to find the default implementation for an internface. It should be in the same 
        /// namespace with the same name without the "I" prefix. For example the default implementation for 
        /// MyNamespace.IMyService would be MyNamespace.MyService
        /// If there's no implementation and the interface is a ServiceContract (suffix "Service" and decorated with DataContractAttribute)
        /// we will look for an implementation with "Client" suffix or create a dynamic proxy using the ChannelFactory if nothing is found. 
        /// </remarks>
        protected override bool HandleMissingBinding(Type requestedType)
        {
            if (!IsViewModel(requestedType) && base.HandleMissingBinding(requestedType))
                return true;            // We only continue if the base couldn't resolve the binding (currently SelfBindable types). 

            if (requestedType.IsGenericType)          // Adjust to use open generics
                requestedType = requestedType.GetGenericTypeDefinition();

            var implementationType = GetDefaultImplementationType(requestedType);

            var providerCallBack = GetProviderCallback(requestedType, implementationType);
            if (providerCallBack != null)
            {
                var binding = new Binding(requestedType) { ProviderCallback = providerCallBack, IsImplicit = true };
                AddBinding(binding);
                return true;
            }

            return false;
        }
            public IEnumerable<IBinding> Resolve(Multimap<Type, IBinding> bindings, IRequest request)
            {
                if (request.Service == typeof(IBar))
                {
                    var binding = new Binding(request.Service);
                    var builder = new BindingBuilder<IBar>(binding, this.kernel, string.Empty);
                    builder.To<Bar>().WithConstructorArgument("name", "parent");
                    return new[] { binding };
                }

                return Enumerable.Empty<IBinding>();
            }
Esempio n. 8
0
        /// <summary>
        /// Attempts to handle a missing binding for a service.
        /// </summary>
        /// <param name="service">The service.</param>
        /// <returns><c>True</c> if the missing binding can be handled; otherwise <c>false</c>.</returns>
        protected virtual bool HandleMissingBinding(Type service)
        {
            Ensure.ArgumentNotNull(service, "service");

            if (!TypeIsSelfBindable(service))
                return false;

            var binding = new Binding(service)
            {
                ProviderCallback = StandardProvider.GetCreationCallback(service),
                IsImplicit = true
            };

            AddBinding(binding);

            return true;
        }
Esempio n. 9
0
        /// <summary>
        /// Injects the specified existing instance, without managing its lifecycle.
        /// </summary>
        /// <param name="instance">The instance to inject.</param>
        /// <param name="parameters">The parameters to pass to the request.</param>
        public virtual void Inject(object instance, params IParameter[] parameters)
        {
            Ensure.ArgumentNotNull(instance, "instance");
            Ensure.ArgumentNotNull(parameters, "parameters");

            Type service = instance.GetType();

            var planner = Components.Get<IPlanner>();
            var pipeline = Components.Get<IPipeline>();

            var binding = new Binding(service);
            var request = CreateRequest(service, null, parameters, false);
            var context = CreateContext(request, binding);

            context.Plan = planner.GetPlan(service);

            var reference = new InstanceReference { Instance = instance };
            pipeline.Activate(context, reference);
        }