AutoMockContainer с поддержкой автонасмешки классов с неинтерфейсными зависимостями

У меня есть конструктор, который имеет неинтерфейсную зависимость:

public MainWindowViewModel(IWorkItemProvider workItemProvider, WeekNavigatorViewModel weekNavigator)

Я использую Moq. Contrib automockcontainer. Если я пытаюсь автодразнить класс MainWindowViewModel, я получаю ошибку из-за зависимости WeekNavigatorViewModel.

Там кто-либо автодразнит контейнеры, который поддерживает насмешку неинтерфейсных типов?

Поскольку Mark показал ниже; да Вы можете!:-) Я заменил Moq. Contrib AutoMockContainer с материалом Mark подарки в его ответе, единственная разница - то, что автоматически сгенерированные насмешки регистрируются как одиночные элементы, но можно сделать это настраивающимся. Вот конечное решение:

/// <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; }
        }
    }
}