public class Order
{
    private int orderId_;
    private IShopDataAccess dataAccess_;
    private OrderLineCollection orderLines_;

    public Order(int orderId, IShopDataAccess dataAccess)
    {
        if (dataAccess == null)
        {
        throw new ArgumentNullException("dataAccess");
        }
        this.orderId_ = orderId;
        this.dataAccess_ = dataAccess;
        this.orderLines_ = new OrderLineCollection(this);
    }

    public OrderLineCollection Lines
    {
        get { return this.orderLines_; }
    }

    public void Save()
    {
        this.dataAccess_.Save(this.orderId_, this);
    }

    internal IShopDataAccess DataAccess
    {
        get { return this.dataAccess_; }
    }
}

internal class SpyShopDataAccess : IShopDataAccess
{
    private bool saveWasInvoked_;

    #region IShopDataAccess Members

    // Other IShopDataAccess members ommitted for brevity

    public void Save(int orderId, Order o)
    {
        this.saveWasInvoked_ = true;
    }

    #endregion

    internal bool SaveWasInvoked
    {
        get { return this.saveWasInvoked_; }
    }
}

[TestMethod]
public void SaveOrderAndVerifyExpectations()
{
    MockRepository mocks = new MockRepository();
    IShopDataAccess dataAccess = mocks.CreateMock<IShopDataAccess>();

    Order o = new Order(6, dataAccess);
    o.Lines.Add(1234, 1);
    o.Lines.Add(4321, 3);

    // Record expectations
    dataAccess.Save(6, o);

    // Start replay of recorded expectations
    mocks.ReplayAll();

    o.Save();

    mocks.VerifyAll();
}

internal class FakeShopDataAccess : IShopDataAccess
{
    private ProductCollection products_;

    internal FakeShopDataAccess()
    {
        this.products_ = new ProductCollection();
    }

    #region IShopDataAccess Members

    public decimal GetProductPrice(int productId)
    {
        if (this.products_.Contains(productId))
        {
            return this.products_[productId].UnitPrice;
        }
        throw new ArgumentOutOfRangeException("productId");
    }

    public void Save(int orderId, Order o) { }

    #endregion

    internal IList<Product> Products
    {
        get { return this.products_; }
    }
}

[TestMethod]
public void CalculateLineTotalsUsingFake()
{
    FakeShopDataAccess dataAccess = new FakeShopDataAccess();
    dataAccess.Products.Add(new Product(1234, 45));
    dataAccess.Products.Add(new Product(2345, 15));

    Order o = new Order(9, dataAccess);
    o.Lines.Add(1234, 3);
    o.Lines.Add(2345, 2);

    Assert.AreEqual<decimal>(135, o.Lines[0].Total);
    Assert.AreEqual<decimal>(30, o.Lines[1].Total);
}

internal class ProductPriceMockShopDataAccess : IShopDataAccess
{
    private Converter<int, decimal> implement_;

    internal ProductPriceMockShopDataAccess(
        Converter<int, decimal> productPriceCallback)
    {
        this.implement_ = productPriceCallback;
    }

    #region IShopDataAccess Members

    public decimal GetProductPrice(int productId)
    {
        return this.implement_(productId);
    }

    public void Save(int orderId, Order o)
    {
        throw new NotImplementedException();
    }

    #endregion
}

[TestMethod]
public void CalculateLineTotalsUsingDelegate()
{
    ProductPriceMockShopDataAccess dataAccess =
        new ProductPriceMockShopDataAccess(delegate(int productId)
    {
        switch (productId)
        {
            case 1234:
                return 45;
            case 2345:
                return 15;
            default:
                throw new ArgumentOutOfRangeException("productId");
        }
    });

    Order o = new Order(10, dataAccess);
    o.Lines.Add(1234, 3);
    o.Lines.Add(2345, 2);

    Assert.AreEqual<decimal>(135, o.Lines[0].Total);
    Assert.AreEqual<decimal>(0, o.Lines[1].Total);
}

internal class MockShopDataAccess : IShopDataAccess
{
    private ImplementationCallback implement_;

    internal MockShopDataAccess(ImplementationCallback callback)
    {
        this.implement_ = callback;
    }

    #region IShopDataAccess Members

    public decimal GetProductPrice(int productId)
    {
        MemberData member = new MemberData("GetProductPrice");
        member.Parameters.Add(new ParameterData("productId", productId));

        this.implement_(member);

        return (decimal)member.ReturnValue;
    }

    public void Save(int orderId, Order o)
    {
        MemberData member = new MemberData("Save");
        member.Parameters.Add(new ParameterData("orderId", orderId));
        member.Parameters.Add(new ParameterData("o", o));

        this.implement_(member);
    }

    #endregion
}

[TestMethod]
public void CalculateLineTotalsUsingManualMock()
{
    MockShopDataAccess dataAccess =
        new MockShopDataAccess(delegate(MemberData member)
    {
        if (member.Name == "GetProductPrice")
        {
            int productId = (int)member.Parameters["productId"].Value;
            switch (productId)
            {
                case 1234:
                    member.ReturnValue = 45m;
                    break;
                case 2345:
                    member.ReturnValue = 15m;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(
                        "productId");
            }
        }
        else
        {
            throw new InvalidOperationException("Unexpected member");
        }
    });

    Order o = new Order(11, dataAccess);
    o.Lines.Add(1234, 3);
    o.Lines.Add(2345, 2);

    Assert.AreEqual<decimal>(135, o.Lines[0].Total);
    Assert.AreEqual<decimal>(30, o.Lines[1].Total);
}