Registering component in autofac - autofac

Question

I'm new to autofac(using 2.1.14.854),and im still trying to put my head around in trying to understand
I have an interface and there are one or more implementations to this interface, and the implementation(s) should be fired in a specific sequence.
For example:
public IPipeline
{
void execute();
}
public MyPipeLine_1:IPipeline
{
public void execute(){}
}
public MyPipeLine_2:IPipeline
{
public void execute(){}
}
foreach(IPipeline pipeline in pipelines)
pipeline.execute();
The order execution of IPipeline should be MyPipleLine_2,MyPipleLine_1, etc
I have two questions
1) how to register all the components, that implements IPipeLine interface in a assembly and place them in a List
2) can i define the order of the execution of these components whilst registering
Thanks in advance.

Answer 1

[A quick note: You're using a really old version of Autofac. You may need to update to get the features I'm talking about.]
The first part is easy - Autofac implicitly supports IEnumerable<T>. Just register all the types and resolve:
var builder = new ContainerBuilder();
builder.RegisterType<MyPipeLine_1>().As<IPipeline>();
builder.RegisterType<MyPipeLine_2>().As<IPipeline>();
var container = builder.Build();
var containsAllPipelineComponents = container.Resolve<IEnumerable<IPipeline>>();
It'd be better if you can take it as an IEnumerable<T> rather than a list, but if you have to have a list, you could add a registration for it:
builder
.Register(c => new List<IPipeline>(c.Resolve<IEnumerable<IPipeline>>()))
.As<IList<IPipeline>>();
The second part isn't as easy. Autofac doesn't necessarily guarantee the order of the items in the list. If you need to order them, you'll need to put some sort of ordering metadata on them - attributes, properties, something that you can use to order the pipeline after the fact.
Alternatively, if your pipeline has "stages" or "events" where different components are applicable, look at the design of your pipeline and have a different pipeline interface per event. Within the event it shouldn't matter what order each item executes in. (This is similar to how event handlers in .NET work now. You'd want to mimic that behavior - different events for different stages in the overall lifecycle, but within each specific stage the order of execution of handlers doesn't matter.)
An example might look like:
public interface IFirstStage
{
void Execute();
}
public interface ISecondStage
{
void Execute();
}
public interface IThirdStage
{
void Execute();
}
public class PipelineExecutor
{
public IEnumerable<IFirstStage> FirstHandlers { get; private set; }
public IEnumerable<ISecondStage> SecondHandlers { get; private set; }
public IEnumerable<IThirdStage> ThirdHandlers { get; private set; }
public PipelineExecutor(
IEnumerable<IFirstStage> first,
IEnumerable<ISecondStage> second,
IEnumerable<IThirdStage> third)
{
this.FirstHandlers = first;
this.SecondHandlers = second;
this.ThirdHandlers = third;
}
public void ExecutePipeline()
{
this.ExecuteFirst();
this.ExecuteSecond();
this.ExecuteThird();
}
public void ExecuteFirst()
{
foreach(var handler in this.FirstHandlers)
{
handler.Execute();
}
}
// ExecuteSecond and ExecuteThird look just
// like ExecuteFirst, but with the appropriate
// set of handlers.
}
Then when you register your handlers it's simple:
var builder = new ContainerBuilder();
builder.RegisterType<SomeHandler>().As<IFirstStage>();
builder.RegisterType<OtherHandler>().As<IFirstStage>();
builder.RegisterType<AnotherHandler>().As<ISecondStage>();
// You can have any number of handlers for any stage in the pipeline.
// When you're done, make sure you register the executor, too:
builder.RegisterType<PipelineExecutor>();
And when you need to run the pipeline, resolve and run.
var executor = container.Resolve<PipelineExecutor>();
executor.ExecutePipeline();
This is just like event handlers but not using delegates. You have a fixed order of pipeline "events" or "stages" but the handlers inside each stage aren't guaranteed order.
If you need to modify the pipeline to have more stages, yes, you'll need to modify code. Just like if you had a new event you wanted to expose. However, to add, remove, or change handlers, you just modify your Autofac registrations.

Answer 2

I suggest you to use Metadata feature.
It gives you an advantage to define the order on registration stage.
Here is an example:
internal class Program
{
private static void Main(string[] args)
{
var builder = new ContainerBuilder();
var s1 = "First";
var s2 = "Second";
var s3 = "Third";
builder.RegisterInstance(s1).As<string>().WithMetadata<Order>(c => c.For(order => order.OrderNumber, 1));
builder.RegisterInstance(s2).As<string>().WithMetadata<Order>(c => c.For(order => order.OrderNumber, 2));
builder.RegisterInstance(s3).As<string>().WithMetadata<Order>(c => c.For(order => order.OrderNumber, 3));
using (var container = builder.Build())
{
var strings = container.Resolve<IEnumerable<Meta<string, Order>>>();
foreach (var s in strings.OrderBy(meta => meta.Metadata.OrderNumber))
{
Console.WriteLine(s.Value);
}
}
Console.ReadKey();
}
public class Order
{
public int OrderNumber { get; set; }
}
}