Ninject 2.0: Inyección de propiedad sin atributo

Question

¿Hay alguna manera de usar la Inyección de propiedades en Ninject 2 sin usar el atributo [Inject]? Esto crea una dependencia de Ninject en la clase que se cableará al usarlo y prefiero evitar tener dependencias innecesarias a mi contenedor IoC, por eso termino usando Constructor Injection más a menudo.

supongo que lo mismo se aplica al método de inyección

Answer 1

Seguí punta de Ruben y registró una pequeña blog post sobre cómo lograr esto, pero aquí está la respuesta rápida:

Crear un atributo personalizado:

public class InjectHereAttribute : Attribute 
{ 
} 

la clase de destino ahora se verá así:

Ahora Ninject debe estar configurado para utilizar el atributo personalizado, esto se puede hacer mediante la creación de una implementación de IInjectionHeuristic que reconoce el atributo personalizado:

public class CustomInjectionHeuristic : NinjectComponent, IInjectionHeuristic, INinjectComponent, IDisposable 
{ 
    public new bool ShouldInject(MemberInfo member) 
    { 
     return member.IsDefined(
      typeof(InjectHereAttribute), 
      true); 
    } 
} 

Y, por último añadir este comportamiento a la Ninject Kernel usando la colección de Componentes, se ejecutará a lo largo de los componentes existentes, es decir, la implementación predeterminada de IInjectionHeuristic, lo que significa que se puede usar el atributo predeterminado o personalizado.

// Add custom inject heuristic 
kernel.Components.Add<IInjectionHeuristic, CustomInjectionHeuristic>(); 

Answer 2

Puede pasar en otro [atributo] tipo de registro al momento de la creación del núcleo que se puede utilizar en lugar de InjectAttribute, pero todavía tendrá que hacer referencia a algo centralmente OOTB.

Hubo una pregunta similar recientemente sobre hacer PI sin atributos - no hay OOTB (como directamente en la interfaz de configuración fluida) para poner en un escáner personalizado pero los puntos de extensibilidad (se agrega un componente que implementa una interfaz Ninject a medida que construyes tu kernel que dicta cómo va a funcionar ese aspecto si buscas un atributo determinado no es lo que quieres) están allí para determinar dónde inyectar según Convention over Configuration: no hay nada que te impida enmendar el escaneo. basado solo en un nombre de atributo (por lo que no necesariamente tiene que vivir en una ubicación central).

Tenga en cuenta que, en general, la inyección de constructor es bueno para un montón de razones de todos modos, incluido éste, y mantener contenedor de código agnóstico es importante (incluso si usted es actualmente feliz con uno!)

Answer 3

que fue capaz de lograr esto usando una clase heurístico:

public sealed class MyInjectionHeuristic : NinjectComponent, IInjectionHeuristic 
{ 
     private static readonly IList<Type> 
      _propertyInjectible = 
       new List<Type> 
       { 
      typeof(IMyService), 
       }; 

        /// <summary> 
     /// Returns a value indicating whether the specified member should be injected. 
     /// </summary> 
     /// <param name="member">The member in question.</param> 
     /// <returns><c>True</c> if the member should be injected; otherwise <c>false</c>.</returns> 
     public bool ShouldInject(MemberInfo member) 
     { 
     var info = member as PropertyInfo; 

     if(member == null || info == null) 
     return false; 

     if (info.CanWrite) 
     return _propertyInjectible.Contains(info.PropertyType); 

     if(this.Settings == null) 
     return false; 

     var propList = member.GetCustomAttributes(this.Settings.InjectAttribute, true); 

     return propList.Length > 0; 
     } 
} 

Al crear el núcleo:

var heuristics = _kernel.Components.Get<ISelector>().InjectionHeuristics; 
    heuristics.Add(new MyInjectionHeuristic()); 

simple añadir otros tipos de IList cuando se quiere inyectar otra tipos a través de propiedades.