Add a key-invariant ICrudRepository which can be implemented by ignorance

Question

In this example, TItem.GetKeyType() is what I'd like to achieve.

Base CRUD repository interface definition:

ICrudRepository<TItem> where TItem : BaseItem where TKey : TItem.GetKeyType()
public Tkey Id { get; set; }

Base Entity definition:

class BaseItem<TKey>
this.GetKeyType = Tkey.GetType()

Entity implementation:

class Book : BaseItem<Int> //declaration of item's tkey

CRUD Interface implementation:

IBooksRepository : ICrudRepository<Book>
BookRepository : IBookRepository --> Ignorance of key struct

This way, whoever implements BooksRepository is forced to use the entity's implementation struct, int in this case. Moreover, I could define new entities using different keys using all the same base entity and crud repository, for example

class Truck : BaseItem<Guid>

Right now there are 2 problems

1. In the CRUD interface, I cannot call TItem.GetKeyType(), even if I know that its type is BaseItem, thus it must define this method
2. I cannot call TKey.GetType() on BaseItem, even if it must be a struct, thus defining this method

Is there a way to achieve this type of pattern, without having to define multiple BaseEntities and CRUD Repositories for each type of key/struct intended to be used, on a system where keys can be of different types?

Answer 1

Ok, I tried this and it seems to work.

The key thing you need in the repo is..

return typeof(TItem).BaseType.GenericTypeArguments[0];

In the BaseItem..

return typeof(TKey);

You cant do the

where TItem : BaseItem<???> 

but you can make BaseItem inherit from a blank RootItem class and use that instead.

However!!

Since this is software engineering rather than stack overflow, I will add that I disapprove of the Generic Repository pattern as a whole.

I think the flaw is that by having a repository per class you lose the relationships between classes and the extra specialised functionality such as GetBooksByAuthorId(string AuthorId)

Edit - full code

class Program
{
    static void Main(string[] args)
    {
        var repo = new BookRepo();
        repo.Items.Add(new Book());
        var item = repo.Items.FirstOrDefault();

        Console.WriteLine(repo.IndexType);
        Console.WriteLine(item.IndexType);
        Console.ReadLine();
    }
}
public abstract class RootItem
{
    public virtual Type IndexType
    {
        get
        {
            return null;
        }
    }
}
public class Item<TKey> : RootItem
{
    public TKey Id { get; set; }

     public override Type IndexType
    {
        get
        {
            return typeof(TKey);
        }
    }
}

public class Book : Item<int>
{

}

public class BaseRepo<TItem> where TItem : RootItem
{
    public List<TItem> Items { get; set; }
    public Type IndexType
    {
        get
        {
            return typeof(TItem).BaseType.GenericTypeArguments[0];
        }
    }
    public BaseRepo()
    {
        this.Items = new List<TItem>();
    }
}

public class BookRepo : BaseRepo<Book>
{

}