using System;

using System.Linq;

using Autofac;

using System.Collections.Generic;

​

namespace Example

{

    public interface IValidationType

    {

        bool Validate();

    }

    public interface IValidatorFor<T> : IValidationType

    {

    }

​

    public class ValidationType1 : IValidatorFor<string>, IValidationType

    {

        public bool Validate() { return true; }

    }

​

    public class ValidationType2 :IValidatorFor<int>,  IValidationType

    {

        public bool Validate() { return true; }

    }

​

    public class ValidationType3 :IValidatorFor<DateTime>,  IValidationType

    {

        public bool Validate() { return true; }

    }

    public interface IValidationFactory

    {

        IEnumerable<T> RetrieveValidations<T>() where T : IValidationType;

        IEnumerable<IValidationType> RetrieveValidations(string validationName);

        IEnumerable<IValidatorFor<T>> RetrieveValidationsFor<T>();

    }

​

    public class ValidationFactory : IValidationFactory

    {

        private readonly IList<IValidationType> _validations;

​

        public ValidationFactory(ILifetimeScope container)

        {

            _validations = container.Resolve<IEnumerable<IValidationType>>().ToList();

        }

​

        public IEnumerable<T> RetrieveValidations<T>() where T : IValidationType

        {

            return _validations.OfType<T>();

        }

​

        public IEnumerable<IValidationType> RetrieveValidations(string validationName) 

        {

            return _validations.Where( v => v.GetType().FullName.Contains(validationName) );  //or some other logic depending on your problem domain

        }

        public IEnumerable<IValidatorFor<T>> RetrieveValidationsFor<T>()

        {

            return _validations.OfType<IValidatorFor<T>>();

        }

​

​

    }

    public class Example1

    {

        protected readonly IEnumerable<IValidationType> _validations;

        public Example1(IValidationFactory factory)

        {

            _validations = factory.RetrieveValidations<ValidationType1>().ToList();

        }

        public void Run()

        {

            Console.WriteLine("Example validators to be used:");

            foreach (var f in _validations)

            {

                Console.WriteLine("{0}", f.GetType().FullName);

            }

        }

    }

​

    public class Example2

    {

        protected readonly IEnumerable<IValidationType> _validations;

        public Example2(IValidationFactory factory)

        {

            _validations = factory.RetrieveValidations("2").ToList();

        }

        public void Run()

        {

            Console.WriteLine("Example2 validators to be used:");

            foreach (var f in _validations)

            {

                Console.WriteLine("{0}", f.GetType().FullName);

            }

        }

    }

​

    public class Example3

    {

        protected readonly IEnumerable<IValidationType> _validations;

        public Example3(IValidationFactory factory)

        {

            _validations = factory.RetrieveValidationsFor<DateTime>().ToList();

        }

        public void Run()

        {

            Console.WriteLine("Example3 validators to be used:");

            foreach (var f in _validations)

            {

                Console.WriteLine("{0}", f.GetType().FullName);

            }

        }

    }

    public class Application

    {

        protected readonly Example1 _example1;

        protected readonly Example2 _example2;

        protected readonly Example3 _example3;

        public Application(Example1 example1, Example2 example2, Example3 example3)

        {

            _example1 = example1;

            _example2 = example2;

            _example3 = example3;

        }

        public void Run()

        {

            _example1.Run();

            _example2.Run();

            _example3.Run();

        }

    }

​

    public class Program

    {

​

        public static IContainer CompositionRoot()

        {

            var builder = new ContainerBuilder();

            builder.RegisterType<ValidationType1>().As<IValidationType>();

            builder.RegisterType<ValidationType2>().As<IValidationType>();

            builder.RegisterType<ValidationType3>().As<IValidationType>();

            builder.RegisterType<ValidationFactory>().As<IValidationFactory>();

            builder.RegisterType<Example1>();

            builder.RegisterType<Example2>();

            builder.RegisterType<Example3>();

            builder.RegisterType<Application>();

            return builder.Build();

        }

        public static void Main()

        {

            CompositionRoot().Resolve<Application>().Run();

        }

    }

}