C# AutoMockContainer，支持具有非接口依赖项的自动模拟类

我有一个具有非接口依赖项的构造函数：

public MainWindowViewModel(IWorkItemProvider workItemProvider, WeekNavigatorViewModel weekNavigator)

我正在使用Moq.Contrib自动模拟容器。如果我尝试自动模拟MainWindowViewModel类，则会由于WeekNavigatorViewModel依赖关系而出现错误

是否有支持模拟非接口类型的自动模拟容器

如下图所示；是的，你可以！：-）我将Moq.Contrib AutoMockContainer替换为Mark在回答中给出的内容，唯一的区别是自动生成的mock注册为singleton，但是您可以配置它。以下是最终解决方案：

/// <summary>
/// Auto-mocking factory that can create an instance of the 
/// class under test and automatically inject mocks for all its dependencies.
/// </summary>
/// <remarks>
/// Mocks interface and class dependencies
/// </remarks>
public class AutoMockContainer
{
    readonly IContainer _container;

    public AutoMockContainer(MockFactory factory)
    {
        var builder = new ContainerBuilder();

        builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
        builder.RegisterSource(new MoqRegistrationSource(factory));

        _container = builder.Build();
    }

    /// <summary>
    /// Gets or creates a mock for the given type, with 
    /// the default behavior specified by the factory.
    /// </summary>
    public Mock<T> GetMock<T>() where T : class
    {
        return (_container.Resolve<T>() as IMocked<T>).Mock;
    }

    /// <summary>
    /// Creates an instance of a class under test, 
    /// injecting all necessary dependencies as mocks.
    /// </summary>
    /// <typeparam name="T">Requested object type.</typeparam>
    public T Create<T>() where T : class
    {
        return _container.Resolve<T>();
    }

    public T Resolve<T>()
    {
        return _container.Resolve<T>();
    }

    /// <summary>
    /// Registers and resolves the given service on the container.
    /// </summary>
    /// <typeparam name="TService">Service</typeparam>
    /// <typeparam name="TImplementation">The implementation of the service.</typeparam>
    public void Register<TService, TImplementation>()
    {
        var builder = new ContainerBuilder();

        builder.RegisterType<TImplementation>().As<TService>().SingleInstance();
        builder.Update(_container);
    }

    /// <summary>
    /// Registers the given service instance on the container.
    /// </summary>
    /// <typeparam name="TService">Service type.</typeparam>
    /// <param name="instance">Service instance.</param>
    public void Register<TService>(TService instance)
    {
        var builder = new ContainerBuilder();

        if (instance.GetType().IsClass)
            builder.RegisterInstance(instance as object).As<TService>();
        else
            builder.Register(c => instance).As<TService>();

        builder.Update(_container);
    }

    class MoqRegistrationSource : IRegistrationSource
    {
        private readonly MockFactory _factory;
        private readonly MethodInfo _createMethod;

        public MoqRegistrationSource(MockFactory factory)
        {
            _factory = factory;
            _createMethod = factory.GetType().GetMethod("Create", new Type[] { });
        }

        public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor)
        {
            var swt = service as IServiceWithType;
            if (swt == null)
            {
                yield break;
            }

            if (!swt.ServiceType.IsInterface)
                yield break;

            var existingReg = registrationAccessor(service);
            if (existingReg.Any())
            {
                yield break;
            }

            var reg = RegistrationBuilder.ForDelegate((c, p) =>
            {
                var createMethod = _createMethod.MakeGenericMethod(swt.ServiceType);
                return ((Mock)createMethod.Invoke(_factory, null)).Object;
            }).As(swt.ServiceType).SingleInstance().CreateRegistration();

            yield return reg;
        }

        public bool IsAdapterForIndividualComponents
        {
            get { return false; }
        }
    }
}

//
///自动模拟工厂，可以创建
///类并自动为其所有依赖项注入模拟。
/// 
/// 
///模拟接口和类依赖关系
/// 
公共类自动模拟容器
{
只读IContainer\u容器；
公共自动模拟容器（模拟工厂）
{
var builder=new ContainerBuilder（）；
RegisterSource（新的AnyConcreteTypeNotAlreadyRegisteredSource（））；
builder.RegisterSource（新MOQRRegistrationSource（工厂））；
_container=builder.Build（）；
}
/// 
///获取或创建给定类型的模拟，并使用
///工厂指定的默认行为。
/// 
公共Mock GetMock（），其中T:class
{
返回（_container.Resolve（）为IMocked）.Mock；
}
/// 
///创建被测试类的实例，
///将所有必要的依赖项作为模拟注入。
/// 
///请求的对象类型。
public T Create（），其中T:class
{
返回_container.Resolve（）；
}
公共事务解决方案
{
返回_container.Resolve（）；
}
/// 
///在容器上注册并解析给定的服务。
/// 
///服务
///服务的实现。
公开作废登记册（）
{
var builder=new ContainerBuilder（）；
builder.RegisterType（）.As（）.SingleInstance（）；
builder.Update（_容器）；
}
/// 
///在容器上注册给定的服务实例。
/// 
///服务类型。
///服务实例。
公共无效寄存器（TService实例）
{
var builder=new ContainerBuilder（）；
if（instance.GetType（）.IsClass）
RegisterInstance（实例作为对象）.as（）；
其他的
Register（c=>instance.As（）；
builder.Update（_容器）；
}
类MoqRegistrationSource:IRegistrationSource
{
私有只读MockFactory\u工厂；
私有只读方法信息_createMethod；
公共MOQRRegistrationSource（模拟工厂）
{
_工厂=工厂；
_createMethod=factory.GetType（）.GetMethod（“创建”，新类型[]{}）；
}
公共IEnumerable Registrationfor（服务、函数注册接受器）
{
var swt=作为IServiceWithType的服务；
if（swt==null）
{
屈服断裂；
}
如果（！swt.ServiceType.IsInterface）
屈服断裂；
var existingReg=注册接受者（服务）；
if（existingReg.Any（））
{
屈服断裂；
}
var reg=RegistrationBuilder.ForDelegate（（c，p）=>
{
var createMethod=\u createMethod.MakeGenericMethod（swt.ServiceType）；
返回（（Mock）createMethod.Invoke（_factory，null））.Object；
}).As（swt.ServiceType）.SingleInstance（）.CreateRegistration（）；
收益率；
}
公共布尔值适用于单个组件
{
获取{return false；}
}
}
}

如果您利用支持请求类型的即时解析的DI容器，您可以非常轻松地自己编写一个

我最近写了一个原型，正是为了这个目的，使用和Moq，但可以使用其他容器代替

以下是相应的IRegistrationSource：

public class AutoMockingRegistrationSource : IRegistrationSource
{
    private readonly MockFactory mockFactory;

    public AutoMockingRegistrationSource()
    {
        this.mockFactory = new MockFactory(MockBehavior.Default);
        this.mockFactory.CallBase = true;
        this.mockFactory.DefaultValue = DefaultValue.Mock;
    }

    public MockFactory MockFactory
    {
        get { return this.mockFactory; }
    }

    #region IRegistrationSource Members

    public IEnumerable<IComponentRegistration> RegistrationsFor(
        Service service,
        Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor)
    {
        var swt = service as IServiceWithType;
        if (swt == null)
        {
            yield break;
        }

        var existingReg = registrationAccessor(service);
        if (existingReg.Any())
        {
            yield break;
        }

        var reg = RegistrationBuilder.ForDelegate((c, p) =>
            {
                var createMethod = 
                    typeof(MockFactory).GetMethod("Create", Type.EmptyTypes).MakeGenericMethod(swt.ServiceType);
                return ((Mock)createMethod.Invoke(this.MockFactory, null)).Object;
            }).As(swt.ServiceType).CreateRegistration();

        yield return reg;
    }

    #endregion
}

---

请注意，您不必在生产代码中使用Autofac（或任何其他DI容器）。

如果MyClass依赖于具体类型而不是接口，这是否有效？是的，Autofac的

AnyConcreteTypeNotAlreadyRegisteredSource负责解析具体类型。我想，在该语句中，模拟注册应明确定义为
SingleInstance
，如（swt.ServiceType）.CreateRegistration（）

。我对NSubstitute有一个问题，如果它不是

SingleInstance

，可能会有问题。例如：

Resolver.Resolve（）.Get（“1”）.Returns（newbasket（1,50））由自动替换容器创建，如果是瞬态的，则返回的代码将永远不会按预期设置，因为它是使用
var sut=Resolver.Resolve（）的新实例在这里IOrderService使用一个新的替换的
ICacheManager
依赖项。
[TestMethod]
public void ContainerCanCreate()
{
    // Fixture setup
    var builder = new ContainerBuilder();
    builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
    builder.RegisterSource(new AutoMockingRegistrationSource());
    var container = builder.Build();
    // Exercise system
    var result = container.Resolve<MyClass>();
    // Verify outcome
    Assert.IsNotNull(result);
    // Teardown
}

public MyClass(ISomeInterface some)