Unity - 解决从T继承的通用实现

Question

I'm using Unity and want to resolve all implementations which have a generic type that is assignable from a specific type.

I currently do the registrations like this:

container.RegisterType<IQueryGenerator<IPerson>, PersonQueryGenerator>("1");
container.RegisterType<IQueryGenerator<ICustomer>, CustomerQueryGenerator>("2");
container.RegisterType<IQueryGenerator<IEmployee>, EmployeeQueryGenerator>("3");
container.RegisterType<IQueryGenerator<IManager>, ManagerQueryGenerator>("4");

Then the hierarchy goes like this:

public interface IPerson
{
}

public interface ICustomer : IPerson
{
}

public interface IEmployee : IPerson
{
}

public interface IManager : IEmployee
{
}

And the interface of the implementations that I'm trying to resolve:

public interface IQueryGenerator<T>
{
   IEnumerable<Expression<Func<T, bool>>>  GenerateQueries();
}

Now I want to be able to resolve all IQueryGenerators where the generic type is assignable to the type I have. So I have a factory which is supposed to wrap it:

    public class QueryFactory
    {
        private readonly IUnityContainer _container;

        public QueryFactory(IUnityContainer container)
        {
            _container = container;
        }

        public IEnumerable<Expression<Func<TModel, bool>>> GenerateQueries<TModel>()
        {
            // Get all querygenerators which can handle TModel.
            IQueryGenerator<TModel>[] queryGenerators = _container.ResolveAll<IQueryGenerator<TModel>>();
            foreach (var queryGenerator in queryGenerators)
            {
                // Do something with queryGenerator.
                var result = queryGenerator.GenerateQueries();
            }
        }
    }

What I want is that _container.ResolveAll<IQueryGenerator<IEmployee>>() returns PersonQueryGenerator , EmployeeQueryGenerator and ManagerQueryGenerator because IManager is an IEmployee and IEmployee is a IPerson .

_container.ResolveAll<IQueryGenerator<ICustomer>>() returns PersonQueryGenerator , and CustomerQueryGenerator .

IEmployee can be casted down to IPerson , which can be handled by PersonQueryGenerator .

How do I register the IQueryGenerators, and how do I resolve them based on TModel ? Or is there any other way to retrieve the QueryGenerators based upon the interfaces TModel implement?

EDIT:

I've added a proof-of-concept of what I want to do. It works well, but is very hard-coded.

class Program
{
    static void Main(string[] args)
    {
        IEnumerable<IManager> managers = new List<IManager>
        {
            new Manager()
            {
                Birthday = DateTime.Now.AddDays(1),
                Name = "Executive Manager",
                EmployeeNumber = 9,
                IsExecutive = true,
                Salary = 1000
            },
            new Manager()
            {
                Birthday = DateTime.Now.AddDays(-1),
                Name = "Ordinary Manager",
                EmployeeNumber = 8,
                IsExecutive = false,
                Salary = 900
            },
        };
        var queries = GenerateQueries();

        managers = queries.Aggregate(managers, (current, expression) => current.Where(expression));
        foreach (var manager in managers)
        {
            Console.WriteLine("Manager: {0}", manager.Name);
        }
        Console.ReadKey();
    }

    // Change this to a generic method.
    static IEnumerable<Func<IManager, bool>> GenerateQueries()
    {
        // Change this to a more generic management
        IList<IQueryGenerator<IManager>> queryGenerators = new List<IQueryGenerator<IManager>>();
        if (typeof(IPerson).IsAssignableFrom(typeof(IManager)))
        {
            queryGenerators.Add(new PersonQueryGenerator());
        }
        if (typeof(IEmployee).IsAssignableFrom(typeof(IManager)))
        {
            queryGenerators.Add(new EmployeeGenerator());
        }
        if (typeof(IManager).IsAssignableFrom(typeof(IManager)))
        {
            queryGenerators.Add(new ManagerQueryGenerator());
        }

        // Fetch queries and return them.
        var queries = new List<Func<IManager, bool>>();
        foreach (var queryGenerator in queryGenerators)
        {
            // Do something with queryGenerator.
            queries.AddRange(queryGenerator.GenerateQueries());
        }
        return queries;
    }

    // I want to use this method instead.
    static IEnumerable<Func<TModel, bool>> GenerateQueries<TModel>()
    {
        // Do the same thing as the method above
        //TODO: Resolve all IQueryGenerators that can handle TModel.
        return null;
    }
}

public interface IQueryGenerator<in T>
{
    IEnumerable<Func<T, bool>> GenerateQueries();
}

public class ManagerQueryGenerator : IQueryGenerator<IManager>
{
    public IEnumerable<Func<IManager, bool>> GenerateQueries()
    {
        Console.WriteLine("ManagerQueryGenerator called");
        yield return x => x.IsExecutive;
    }
}

public class PersonQueryGenerator : IQueryGenerator<IPerson>
{
    public IEnumerable<Func<IPerson, bool>> GenerateQueries()
    {
        Console.WriteLine("PersonQueryGenerator called");
        yield return x => x.Birthday > DateTime.Now;
    }
}

public class EmployeeGenerator : IQueryGenerator<IEmployee>
{
    public IEnumerable<Func<IEmployee, bool>> GenerateQueries()
    {
        Console.WriteLine("EmployeeGenerator called");
        yield return x => x.Salary > 900;
    }
}

public interface IHaveName
{
    string Name { get; set; }
}

public interface IPerson : IHaveName
{
    DateTime Birthday { get; set; }
}

public interface ICustomer : IPerson
{
    int MoneyToSpend { get; set; }
}

public interface IEmployee : IPerson
{
    int EmployeeNumber { get; set; }
    int Salary { get; set; }
}

public interface IManager : IEmployee
{
    bool IsExecutive { get; set; }
}

public class Manager : IManager
{
    public string Name { get; set; }
    public DateTime Birthday { get; set; }
    public int EmployeeNumber { get; set; }
    public int Salary { get; set; }
    public bool IsExecutive { get; set; }
}

Output is:

PersonQueryGenerator called
EmployeeGenerator called
ManagerQueryGenerator called
Manager: Executive Manager

This is what I want, but with a more generic type management and I really would like to use Expression<Func<T,bool>> because it will be used with EF.

public interface IQueryGenerator<T>
{
   IEnumerable<Expression<Func<T, bool>>>  GenerateQueries();
}

Instead of:

public interface IQueryGenerator<in T>
{
   IEnumerable<Func<T, bool>>  GenerateQueries();
}

Answer 1

It is possible with little bit reflection when you're filling the unity container.

private static UnityContainer container = new UnityContainer();

static void RegisterGenerator<T, TG>() where TG : IQueryGenerator<T>
{
  var assembly = typeof(T).Assembly;
  // walk trough all interfaces in assembly, if the interface inherits from
  // typeof(T), add that particular IQueryGenerator<> to container as well
  foreach (var type in assembly.GetTypes())
  {
    if (typeof(T).IsAssignableFrom(type) && type.IsInterface)
    {
      var generatorType = typeof(IQueryGenerator<>).MakeGenericType(type);
      container.RegisterType(generatorType, typeof(TG), type.Name);
    }
  }
}

static IEnumerable<Func<T, bool>> GenerateQueries<T>() where T : IPerson
{
  var queryGenerators = container.ResolveAll<IQueryGenerator<T>>().ToList();

  // Fetch queries and return them.
  var queries = new List<Func<T, bool>>();
  foreach (var queryGenerator in queryGenerators)
  {
    // Do something with queryGenerator.
    queries.AddRange(queryGenerator.GenerateQueries());
  }
  return queries;
}

Example:

static void Main(string[] args)
{
  RegisterGenerator<IPerson, PersonQueryGenerator>();
  RegisterGenerator<IManager, ManagerQueryGenerator>();

  var managers = new List<IPerson>
  {
    new Manager
    {
      Birthday = DateTime.Now.AddDays(1),
      Name = "Executive Manager",
      EmployeeNumber = 9,
      IsExecutive = true,
      Salary = 1000
    },
    new Manager
    {
      Birthday = DateTime.Now.AddDays(-1),
      Name = "Ordinary Manager",
      EmployeeNumber = 8,
      IsExecutive = false,
      Salary = 900
    }
  }.AsEnumerable();
  var queries = GenerateQueries<IPerson>();

  managers = queries.Aggregate(managers, (current, expression) => current.Where(expression));
  foreach (var manager in managers)
  {
    Console.WriteLine("Manager: {0}", manager.Name);
  }
  Console.ReadKey();
}

Answer 2

using System;
using System.Collections.Generic;
using System.Linq;
using Unity;

namespace ConsoleApplication1
{
    internal class Program
    {
        private static UnityContainer container = new UnityContainer();

        private static void Main(string[] args)
        {
            container.RegisterType<Manager>(new ContainerControlledLifetimeManager());
            container.RegisterType<IPerson, Manager>();
            container.RegisterType<IEmployee, Manager>();
            container.RegisterType<IManager, Manager>();
            container.RegisterType<IQueryGenerator<IPerson>, PersonQueryGenerator>();
            container.RegisterType<IQueryGenerator<IEmployee>, EmployeeGenerator>();
            container.RegisterType<IQueryGenerator<IManager>, ManagerQueryGenerator>();

            IEnumerable<IManager> managers = new List<IManager>
            {
                new Manager()
                {
                    Birthday = DateTime.Now.AddDays(1),
                    Name = "Executive Manager",
                    EmployeeNumber = 9,
                    IsExecutive = true,
                    Salary = 1000
                },
                new Manager()
                {
                    Birthday = DateTime.Now.AddDays(-1),
                    Name = "Ordinary Manager",
                    EmployeeNumber = 8,
                    IsExecutive = false,
                    Salary = 900
                },
            };

            // Fetch queries and return them.
            var queries = new List<Func<IManager, bool>>();
            queries.AddRange(GenerateQueries<IPerson>());
            queries.AddRange(GenerateQueries<IEmployee>());
            queries.AddRange(GenerateQueries<IManager>());

            managers = queries.Aggregate(managers, (current, expression) => current.Where(expression));
            foreach (var manager in managers)
            {
                Console.WriteLine("Manager: {0}", manager.Name);
            }

            Console.ReadKey();
        }

        // I want to use this method instead.
        private static IEnumerable<Func<TModel, bool>> GenerateQueries<TModel>()
        {
            var queryGenerator = container.Resolve<IQueryGenerator<TModel>>();

            return queryGenerator.GenerateQueries();
        }
    }

    public interface IQueryGenerator<in T>
    {
        IEnumerable<Func<T, bool>> GenerateQueries();
    }

    public class ManagerQueryGenerator : IQueryGenerator<IManager>
    {
        public IEnumerable<Func<IManager, bool>> GenerateQueries()
        {
            Console.WriteLine("ManagerQueryGenerator called");
            yield return x => x.IsExecutive;
        }
    }

    public class PersonQueryGenerator : IQueryGenerator<IPerson>
    {
        public IEnumerable<Func<IPerson, bool>> GenerateQueries()
        {
            Console.WriteLine("PersonQueryGenerator called");
            yield return x => x.Birthday > DateTime.Now;
        }
    }

    public class EmployeeGenerator : IQueryGenerator<IEmployee>
    {
        public IEnumerable<Func<IEmployee, bool>> GenerateQueries()
        {
            Console.WriteLine("EmployeeGenerator called");
            yield return x => x.Salary > 900;
        }
    }

    public interface IHaveName
    {
        string Name { get; set; }
    }

    public interface IPerson : IHaveName
    {
        DateTime Birthday { get; set; }
    }

    public interface ICustomer : IPerson
    {
        int MoneyToSpend { get; set; }
    }

    public interface IEmployee : IPerson
    {
        int EmployeeNumber { get; set; }
        int Salary { get; set; }
    }

    public interface IManager : IEmployee
    {
        bool IsExecutive { get; set; }
    }

    public class Manager : IManager
    {
        public string Name { get; set; }
        public DateTime Birthday { get; set; }
        public int EmployeeNumber { get; set; }
        public int Salary { get; set; }
        public bool IsExecutive { get; set; }
    }
}