Автоопределение Generic-типов внутри Generic (Get<TEntity>() where TEntity: IEntity<TId>)?

Question

[Вадим Мартынов]

Привет, народ!
У меня вечно возникают проблемы с generic.
Есть следующая структура классов:

class Entity<TId> where TId : struct 
{ 
    public virtual TId Id { get; set; } 
}

interface IRepository<T, in TId> where T : Entity<TId> where TId : struct 
{ 
    T Get(TId id); 
    IList<T> GetAll(); ... 
}

class RepositoryProvider
{
        public IRepository<TEntity, TId> GetRepository<TEntity, TId>() where TEntity : Entity<TId> where TId : struct
        { ... }
}

Мне не нравится необходимость при вызове GetRepository указывать оба дженерик-параметра. Ведь когда я подставляю первый параметр, то из него можно извлечь информацию о втором. Класс не может дважды наследовать Entity с разными TId, значит информация однозначная.
Я хочу иметь возможность написать:
provider.GetRepository<Department>();
вместо
provider.GetRepository<Department, int>();

Но при попытке объявить метод следующим образом:

public IRepository<TEntity, TId> GetRepository<TEntity>() where TEntity : Entity<TId> where TId : struct

возникает очевидная ошибка компиляции "The type or namespace name 'TId' could not be found (are you missing a using directive or an assembly reference?)".

Есть ли способ обойти это ограничение? Устроила бы рефлексия или Emit, но как их тут применить не представляю. Прошу прощения за сумбурный способ изложения мыслей.

Answer 1

[Антон]

Может чем поможет:

RepositoryProvider provider = new RepositoryProvider();
dynamic repo = provider.GetRepository<Entity<int>>();
List<Entity<int>> list = repo.GetAll();
Entity<int> entry = repo.Get(10);

interface Entity { }

class Entity<TId> : Entity
    where TId : struct
{
    public virtual TId Id { get; set; }
}

interface IRepository<T, in TId>
    where T : Entity<TId>
    where TId : struct
{
    T Get(TId id);
    IList<T> GetAll();
}

class Repo<T, TId> : IRepository<T, TId>
    where T : Entity<TId>
    where TId : struct
{
    public T Get(TId id)
    {
        return default(T);
    }

    public IList<T> GetAll()
    {
        return new List<T>();
    }
}

class RepositoryProvider
{
    public dynamic GetRepository<TEntity>()
        where TEntity : Entity
    {
        Type genericParam = typeof(TEntity).GetGenericArguments()[0];
        return Activator.CreateInstance(typeof(Repo<,>).MakeGenericType(typeof(TEntity), genericParam));
    }
}

Comments

[Вадим Мартынов]

Спасибо за ответ.
dynamic действительно является одним из решений проблемы, но поскольку RepositoryProvider подразумевается как API для внешних пользователей библиотеки, то такое решение может испугать пользователя класса.
Собственно, речь идёт как раз о косметическом улучшении для пользователя - нет необходимости указывать параметр в generic, который и так можно извлечь.
Я поигрался с твоим вариантом, попытавшись как-нибудь скастать результат к нужному типу, но, видимо, само устройство interface IRepository мешает получить необходимый мне результат.
Корень зла как раз в лишнем параметре IRepository, который принимает T : Entity, но при этом вынужден получать TId извне, хотя может извлечь его из Entity.

[Антон]

Может стоит сделать немного на оборот?
Указывать TId и создавать Entity на основе этого, а для более слабой связи использовать интерфейс?

Хотя мне кажется вы об этом уже думали.

Примерно такое:

RepositoryProvider provider = new RepositoryProvider();
IRepository<int> repo = provider.GetRepository<int>();
IList<IEntity<int>> list = repo.GetAll();
IEntity<int> entry = repo.Get(10);

interface IEntity<TId>
    where TId : struct
{
    TId Id { get; set; }
}

class Entity<TId> : IEntity<TId>
    where TId : struct
{
    public virtual TId Id { get; set; }
}

interface IRepository<TId> 
    where TId : struct
{
    IEntity<TId> Get(TId id);
    IList<IEntity<TId>> GetAll();
}

class Repo<TId> : IRepository<TId>
    where TId : struct
{
    public IEntity<TId> Get(ValueType id)
    {
        return default(Entity<TId>);
    }

    public IList<IEntity<TId>> GetAll()
    {
        return new List<IEntity<TId>>();
    }
}

class RepositoryProvider
{
    public IRepository<TId> GetRepository<TId>()
        where TId : struct
    {
        return new Repo<TId>();
    }
}

[Вадим Мартынов]

Нет, сценарий использования подразумевает, что пользователь будет ждать именно TEntity. То есть при запросе репозитория депортаментов юзер сразу хочет видеть департаменты после Get или GetAll.
Но идея сделать наоборот мне понравилась. Я немного распишу сценарий чтобы обосновать своё решение. Библиотека предназначена для ускорения разработки при работе с EF Code first в случае использования IoC в проекте. Пользователь:
1. наследует доменные объекты от Entity<TId>.
2. Вызывает в контейнере на этапе инициализации

container.RegisterRepositories(/* тут скорее всего assembly с entity-классами */)

При этом в пункте 2 происходит следующее - для каждого класса в assembly, относледованного от Entity<TId> генерируется код класса-наследника от RepositoryBase<T, TId> и этот класс регистрируется в контейнере под интерфейсом IRepository<T, TId>
То есть пользователь завёл просто ентити-классы, а у него уже есть такой чудесный набор методов для каждого:

public interface IRepository<T, in TID> : IRepository
    where TID : struct 
{
    T Get(TID id);
    IList<T> Get(Action<RepositoryQuery<T>> query, out int totalCount);
    IList<TMap> Get<TMap>(Action<RepositoryQuery<TMap>> queryAction, out int totalCount) where TMap : class;
    IList<TMap> Get<TMap>(Action<RepositoryQuery<T>> queryAction, Action<RepositoryQuery<TMap>> mapAction, out int totalCount) where TMap : class;
    IList<T> Get(Action<RepositoryQuery<T>> query);
    IList<TMap> Get<TMap>(Action<RepositoryQuery<TMap>> queryAction) where TMap : class;
    IList<TMap> Get<TMap>(Action<RepositoryQuery<T>> queryAction, Action<RepositoryQuery<TMap>> mapAction) where TMap : class;
    IList<T> GetAll();
    T Save(T entity);
    void Delete(T entity);
}

Всё готово и не нужно реализовывать однообразный доступ к данным, просто берешь и

var repository = _repProvider.GetRepository<Department>();
repository.Get(q => q.Filter(cd => !cd.IsDeleted).Include("Employees", "Organization", "SomeAnotherLinkedPropertyInModel"));

----------------------------------------------------------------
Теперь решение.
Если пользователь хочет простой доступ из коробки, то он делает

container.RegisterRepositories(/* тут скорее всего assembly с entity-классами */)

И при необходимости получить репозиторий делает так:

var repository = _repProvider.GetRepository<Department, Int32>();

Не идеально, но безопасно. Проверка, что ключ у Department именно Int32 есть, всё ок.
Второй способ работы с библиотекой состоит в том, что пользователь сам пишет интерфейсы репозиториев, помечая их специальным аттрибутом:

[Repository]
public interface IUserRepository : IRepository<User, Int32> { }

[Repository]
public interface IDepartmentRepository : IRepository<Department, Int32> { }

И при инициализации на шаге 2 для каждого класса, реализующего Entity ищется соответствие среди интерфейсов, помеченных RepositoryAttribute, и автосгенерированный класс регистрируется и как IRepository и под своим собственным интерфейсом (IDepartmentRepository).

При этом интерфейс провайдера репозиториев будет таким:

public interface IRepositoryProvider
{
    TRespositoryType GetRepository<TRespositoryType>() where TRespositoryType : IRepository;
    IRepository<TEntity, TId> GetRepository<TEntity, TId>() where TEntity : Entity<TId> where TId : struct;
}

Это не идеальное решение, но в первой итерации такую реализацию можно протестировать на реальных пользователях :)

Спасибо за помощь, свежего взгляда на проблему мне не хватает при работе в одиночку.

[Вадим Мартынов]

Понимаю, что комментирую это уже скорее для самодокументации, но вспомнил способ без необходимости вручную объявлять интерфейс для каждой сущности. Можно поступить так же, как я делал с автофабриками

Вот примеры кода:

/// <summary>
/// Базовый класс для всех доменных объектов.
/// </summary>
[DataContract]
public abstract class Entity<TId> : IEntity<TId> 
    where TId : struct
{
    /// <summary>
    /// Идентификатор.
    /// </summary>
    [DataMember]
    [Key]
    public virtual TId Id { get; set; }

    [Repository]
    public interface Repository : IRepository<Entity<TId>, TId>
    {
    }
}

public interface IRepositoryProvider
{
    IRepository<TEntity, TId> GetRepository<TEntity, TId>() where TEntity : Entity<TId> where TId : struct;
}

IRepositoryProvider rp = ...;
var rep = rp.GetRepository<Department.Repository>();

Любителям эстетики может не понравиться конструкция Department.Repository, но с отсутствием необходимости самостоятельно прописывать интерфейсы репозиториев получается вкусно.