Se garantiza el orden de las dependencias cuando se inyecta IEnumerable <T>

Question

Me registro en los servicios de contenedor que implementan IMyService.

¿Tengo garantías acerca de su orden en

container.Resolve<IEnumerable<IMyService>> 

?

Answer 1

No, no hay pedidos garantizados aquí. Hemos considerado extensiones para habilitarlo, pero por ahora es algo que debemos manejar manualmente.

Answer 2

Así como ayuda adicional para personas como yo que aterrizan en esta página ... Aquí hay un ejemplo de cómo se puede hacer.

public static class AutofacExtensions 
    { 
    private const string OrderString = "WithOrderTag"; 
    private static int OrderCounter; 

    public static IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> 
     WithOrder<TLimit, TActivatorData, TRegistrationStyle>(
     this IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> registrationBuilder) 
    { 
     return registrationBuilder.WithMetadata(OrderString, Interlocked.Increment(ref OrderCounter)); 
    } 

    public static IEnumerable<TComponent> ResolveOrdered<TComponent>(this IComponentContext context) 
    { 
     return from m in context.Resolve<IEnumerable<Meta<TComponent>>>() 
      orderby m.Metadata[OrderString] 
      select m.Value; 
    } 
    } 

Answer 3

no me refiero a la libre promover, pero también he creado un paquete para resolver este problema porque tenía una necesidad similar: https://github.com/mthamil/Autofac.Extras.Ordering

Utiliza el IOrderedEnumerable < T> interfaz para declarar la necesidad de ordenar.

Answer 4

Sé que esta es una publicación anterior, pero para mantener el orden de registro, ¿no podemos simplemente usar PreserveExistingDefaults() durante el registro?

builder.RegisterInstance(serviceInstance1).As<IService>().PreserveExistingDefaults();  
builder.RegisterInstance(serviceInstance2).As<IService>().PreserveExistingDefaults(); 

// services should be in the same order of registration 
var services = builder.Resolve<IEnumberable<IService>>(); 

Answer 5

no he encontrado ninguna información nueva sobre el tema y escribió un ensayo que es tan simple como (es mejor que escribir su propia):

var cb = new ContainerBuilder(); 
cb.RegisterType<MyClass1>().As<IInterface>(); 
// ... 
using (var c = cb.Build()) 
{ 
    using (var l = c.BeginLifetimeScope()) 
    { 
     var e = l.Resolve<IEnumerable<IInterface>>().ToArray(); 
     var c = l.Resolve<IReadOnlyCollection<IInterface>>(); 
     var l = l.Resolve<IReadOnlyList<IInterface>>(); 
     // check here, ordering is ok 
    } 
} 

pedidos se mantuvo para todos los casos que Ya se me ocurrió. Sé que no es confiable, pero creo que en la versión actual de Autofac (4.6.0) el orden se guarda con prudencia.