Autofac: DependencyResolutionException FluentValidation.IValidator

Everything is working fine except IValidator injection.

I get an error like below:

Autofac.Core.DependencyResolutionException: 'An error occurred during the activation of a particular registration. See the inner exception for details. Registration: Activator = SampleCommandHandler (ReflectionActivator), Services = [MyApp.Domain.Core.ICommandHandler`1[[MyApp.Domain.SampleCommand, MyApp.Domain, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]], Lifetime = Autofac.Core.Lifetime.CurrentScopeLifetime, Sharing = None, Ownership = OwnedByLifetimeScope'

Inner Exception DependencyResolutionException: None of the constructors found with 'Autofac.Core.Activators.Reflection.DefaultConstructorFinder' on type 'MyApp.Domain.SampleCommandHandler' can be invoked with the available services and parameters: Cannot resolve parameter 'FluentValidation.IValidator1[MyApp.Domain.SampleCommand] sampleCommandValidator' of constructor 'Void .ctor(MyApp.Domain.ISampleRepository, FluentValidation.IValidator1[MyApp.Domain.SampleCommand])'.

My application is Web API... And my reference project: https://github.com/Weapsy/Weapsy.CMS

namespace MyApp.Service.WebAPI
{
    /// <summary>
    /// http://autofac.readthedocs.io/en/latest/register/scanning.html#scanning-for-modules
    /// </summary>
    public class AutofacModule : Autofac.Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            // MyApp.Application.Core
            builder.RegisterAssemblyTypes(typeof(IService).GetTypeInfo().Assembly).AsImplementedInterfaces();

            // MyApp.Application
            builder.RegisterAssemblyTypes(typeof(ISampleService).GetTypeInfo().Assembly).AsImplementedInterfaces();

            // MyApp.Domain.Core
            builder.RegisterAssemblyTypes(typeof(IResolver).GetTypeInfo().Assembly).AsImplementedInterfaces();

            // MyApp.Domain
            builder.RegisterAssemblyTypes(typeof(ISampleRepository).GetTypeInfo().Assembly).AsImplementedInterfaces();
            //builder.RegisterAssemblyTypes(typeof(SampleApplyCommand).GetTypeInfo().Assembly).AsImplementedInterfaces();

            // MyApp.Infrastructure.Data
            builder.RegisterAssemblyTypes(typeof(IDbFactory).GetTypeInfo().Assembly).AsImplementedInterfaces();   
        }
    }
}

namespace MyApp.Service.WebAPI
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services

            var builder = new ContainerBuilder();
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            builder.RegisterModule(new AutofacModule());
            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // Web API routes
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }
    }
}

namespace MyApp.Domain
{
    public class SampleCommandHandler : ICommandHandler<SampleCommand>
    {
        private readonly ISampleRepository _sampleRepository;
        private readonly IValidator<SampleCommand> _sampleCommandValidator;

        public SampleCommandHandler(ISampleRepository sampleRepository, IValidator<SampleCommand> sampleCommandValidator)
        {
            _sampleRepository = sampleRepository;
            _sampleCommandValidator = sampleCommandValidator;
        }

        public IEnumerable<IEvent> Handle(SampleCommand command)
        {
            var validate = _sampleCommandValidator.Validate(command);
            if (!validate.IsValid)
            {
                throw new DomainException(validate.Errors.Select(s => s.ErrorMessage));
            }

            var sample = _sampleRepository.Read(command.SampleNumber);

            sample.Apply(command);

            _sampleRepository.Update(sample);

            return sample.Events;
        }
    }
}

namespace MyApp.Domain
{
    public class SampleCommand : ICommand
    {
        public SampleCommand()
        {
        }

        public SampleCommand(string sampleNumber)
        {
            SampleNumber = sampleNumber;
        }

        public string SampleNumber { get; set; }
    }
}

namespace MyApp.Domain
{
    public class SampleValidator<T> : AbstractValidator<T> where T : SampleCommand
    {
        private readonly ISampleRules _sampleRules;

        public SampleValidator(ISampleRules sampleRules)
        {
            _sampleRules = sampleRules;

            RuleFor(rule => rule.SampleNumber)
                .NotEmpty().WithMessage(DomainValidationMessages.SampleNumberCannotBeEmpty);
        }
    }
}

namespace MyApp.Domain.Core
{
    public interface IResolver
    {
        T Resolve<T>();
        IEnumerable<T> ResolveAll<T>();
    }
}

namespace MyApp.Domain.Core
{
    public class AutofacResolver : IResolver
    {
        private readonly IComponentContext _context;

        public AutofacResolver(IComponentContext context)
        {
            _context = context;
        }

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

        public IEnumerable<T> ResolveAll<T>()
        {
            return _context.Resolve<IEnumerable<T>>().ToList();
        }
    }
}

Layers:

MyApp.Service.WebAPI

MyApp.Application

MyApp.Application.Core

MyApp.Domain

MyApp.Domain.Core

MyApp.Infrastructure.Data

I have tried everything to solve but didn't work. Help!