注册两个继承相同接口的组件

我是autoface的新手，我正在努力理解这个概念。基本上就是浏览他们网站上的样本。我正在玩一些代码，我不理解以下内容。

如果我注册两个类似的组件，如todaywriter和昨天的作家解析我的容器，它只写出最后注册的一个，所以在这种情况下，它只会写出今天的日期，而忽略昨天的日期。到底发生了什么?我不能注册从同一接口继承的2个组件?如果可以的话，我要怎么把它们都展示出来呢?

class Program
{
    private static IContainer Container { get; set; }
    static void Main(string[] args)
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<ConsoleOutput>().As<IOutput>();
        builder.RegisterType<yesterdayWriter>().As<IDateWriter>();
        builder.RegisterType<TodayWriter>().As<IDateWriter>();
        Container = builder.Build();
        WriteDate();
    }
    public static void WriteDate()
    {
        // Create the scope, resolve your IDateWriter,
        // use it, then dispose of the scope.
        using (var scope = Container.BeginLifetimeScope())
        {
            var writer = scope.Resolve<IDateWriter>();
            writer.WriteDate();
            Console.ReadLine();
        }
    }
}

// This implementation of the IOutput interface
// is actually how we write to the Console. Technically
// we could also implement IOutput to write to Debug
// or Trace... or anywhere else.
public class ConsoleOutput : IOutput
{
    public void Write(string content)
    {
        Console.WriteLine(content);
    }
}
// This interface helps decouple the concept of
// "writing output" from the Console class. We
// don't really "care" how the Write operation
// happens, just that we can write.
public interface IOutput
{
    void Write(string content);
}
// This interface decouples the notion of writing
// a date from the actual mechanism that performs
// the writing. Like with IOutput, the process
// is abstracted behind an interface.
public interface IDateWriter
{
    void WriteDate();
}
// This TodayWriter is where it all comes together.
// Notice it takes a constructor parameter of type
// IOutput - that lets the writer write to anywhere
// based on the implementation. Further, it implements
// WriteDate such that today's date is written out;
// you could have one that writes in a different format
// or a different date.
public class TodayWriter : IDateWriter
{
    private IOutput _output;
    public TodayWriter(IOutput output)
    {
        this._output = output;
    }
    public void WriteDate()
    {
        this._output.Write(DateTime.Today.ToShortDateString());
    }
}
// This TodayWriter is where it all comes together.
// Notice it takes a constructor parameter of type
// IOutput - that lets the writer write to anywhere
// based on the implementation. Further, it implements
// WriteDate such that today's date is written out;
// you could have one that writes in a different format
// or a different date.
public class yesterdayWriter : IDateWriter
{
    private IOutput _output;
    public yesterdayWriter(IOutput output)
    {
        this._output = output;
    }
    public void WriteDate()
    {
        this._output.Write(DateTime.Today.AddDays(-1).ToShortDateString());
    }
}

foreach (var writer in scope.Resolve<IEnumerable<IDateWriter>>())
{
    writer.WriteDate();
}

public class AggregatedDateWriter : IDateWriter
{
    public AggregatedDateWriter(IEnumerable<IDateWriter> writers)
    {
        this._writers = writers; 
    }

    private readonly IEnumerable<IDateWriter> _writers;

    public void WriteDate()
    {
        foreach (IDateWriter writer in this._writers)
        {
            writer.WriteDate();
        }
    }
}

builder.RegisterType<yesterdayWriter>()
        .Named<IDateWriter>("concrete");
builder.RegisterType<TodayWriter>()
        .Named<IDateWriter>("concrete");
builder.RegisterType<AggregatedDateWriter>()
        .As<IDateWriter>()
        .WithParameter((pi, c) => pi.Name == "writers", 
                        (pi, c) => c.ResolveNamed<IEnumerable<IDateWriter>>("concrete"));