MEF注入容器

我正在使用MEF构建一个简单的应用程序来更好地理解它，我面临一个问题。该应用程序是一个简单的计算器，你可以创建新的操作。每个操作都是一个导出IOperation的类。下面是ADD操作类:

[Export(typeof(IOperation))]
internal class Add : IOperation
{
    CompositionContainer _container;
    public string Name
    {
        get { return "Add"; }
    }
    public string Symbol
    {
        get { return "+"; }
    }
    public IOperand Compute(params IOperand[] operands)
    {
        IOperand result = _container.GetExportedValue<IOperand>();
        result.Value = operands.Sum(e => e.Value);
        return result;
    }
}

(IOperand)是一个只公开double类型的接口。这样做的原因是在版本2中，你可以有一个表达式，如"(2+2)*4")

我的问题，你可以看到的是，_container是空的，当我击中Compute。这个具体类是在容器组成一个[ImportMany(typeof(IOperation))]时创建的。所以我的问题是:有没有一种方法来告诉容器谁是反转控制传递自己的引用到这个对象?

PS:我不想让_container成为公共财产。

Edit1:这是目前为止IOperand的唯一实现:

[Export(typeof(IOperand))]
public class SimpleResult : IOperand
{
    private double _value;
    public double Value
    {
        get
        {
            return _value;
        }
        set
        {
            _value = value;
        }
    }
}

这是"Main"，合成发生的地方:

public class Calculator
{
    [ImportMany(typeof(IOperation))]
    private List<IOperation> _knownOperations;
    private List<ICalculatorButton> _buttons;
    private CompositionContainer _container;
    public Calculator()
    {
        _container = new CompositionContainer(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
        _container.SatisfyImportsOnce(this);
        _buttons = new List<ICalculatorButton>();
        ICalculatorButton button;
        for (int i = 0; i < 10; i++)
        {
            button = _container.GetExportedValue<IDigitButton>();
            button.Symbol = i.ToString();
            ((IDigitButton)button).Value = i;
            _buttons.Add(button);
        }
        foreach (IOperation op in _knownOperations)
        {
            button = _container.GetExportedValue<IOperationButton>();
            button.Symbol = op.Symbol;
            ((IOperationButton)button).Operation = op;
            _buttons.Add(button);
        }
    }
    public IReadOnlyList<IOperation> KnownOperations
    {
        get { return _knownOperations.AsReadOnly(); }
    }
    public IReadOnlyList<ICalculatorButton> Buttons
    {
        get { return _buttons.AsReadOnly(); }
    }
    public IOperand Calculate(IOperation operation, params IOperand[] operands)
    {
        IOperand result = operation.Compute(operands);
        return result;
    }
    public IOperand Calculate(IOperation operation, params double[] operands)
    {
        List<IOperand> res = new List<IOperand>();
        foreach (double item in operands)
        {
            IOperand aux = _container.GetExportedValue<IOperand>();
            aux.Value = item;
            res.Add(aux);
        }
        return Calculate(operation, res.ToArray());
    }
}