C＃：专用模板方法-错误：类型“…”已经定义了具有相同参数类型的成员“…”

Question

I'm quite new to C# and currently developing an application using the EntityFramework. I would like to extend the functionality of the database context class, so that I can call a method getPool() so that it hands out the according DbSet member of the class.

I need to implement it as a template as it will be later called from other templates, which are just knowing about the (global) database context object and a type T (having a given superclass) for which they shall query the database.

Here is what I tried (a bit simplified - original example is too complicated):

public class TestContext : DbContext
{
    public DbSet<TestA> ATests { get; set; }
    public DbSet<TestB> BTests { get; set; }

    public IQueryable<T> getPool<T>() where T : TestA {
       return (IQueryable<T>)ATests;
    }
    public IQueryable<T> getPool<T>() where T : TestB {
       return (IQueryable<T>)BTests;
    }
}

The error message is

Error: Type '...' already defines a member called '...' with the same parameter types .

And it occurs at the line of the second specialized definition of my template ( public IQueryable<T> getPool<T>() where T : TestB ).

The question is: How to fix this?

Answer 1

Unfortunately, in C#, you cannot overload a method by using a generic type constraint like this. You will have to give them different names like this

public class TestContext : DbContext
{
    public DbSet<TestA> ATests { get; set; }
    public DbSet<TestB> BTests { get; set; }

    public IQueryable<T> getPoolA<T>() where T : TestA {
       return (IQueryable<T>)ATests;
    }
    public IQueryable<T> getPoolB<T>() where T : TestB {
       return (IQueryable<T>)BTests;
    }
}

Another solution would be to do something like this:

public class TestContext : DbContext
{
    public DbSet<TestA> ATests { get; set; }
    public DbSet<TestB> BTests { get; set; }

    public IQueryable<T> getPool<T>() {
       return (typeof(T) == typeof(TestA))
                  ? (IQueryable<T>)ATests
                  : (IQueryable<T>)BTests;
    }
}

Now, you can make this even cleaner, since IQueryable<T> is covariant in T , you can avoid casting:

public class TestContext : DbContext
{
    public DbSet<TestA> ATests { get; set; }
    public DbSet<TestB> BTests { get; set; }

    public IQueryable<T> getPool<T>() {
       return (typeof(T) == typeof(TestA)) ? ATests : BTests;
    }
}

---

If you want to avoid testing for types you can do something like this:

public class TestContext : DbContext
{
    readonly Dictionary<Type, object> _sets;

    public DbSet<TestA> ATests { get; set; }
    public DbSet<TestB> BTests { get; set; }

    public TestContext()
    {
        _sets = new Dictionary<Type, object>
        {
            { typeof(TestA), ATests },
            { typeof(TestB), BTests }
        }
    }

    public IQueryable<T> getPool<T>() {
       return (IQueryable<T>)_sets[typeof(T)];
    }
}

Answer 2

I'd recommend (besides of reading about generics and C# in general) to configure the pool with desired types on run time, store them in dictionaries and use the Type as key, ie something along the following lines...:

//...

// configuration, maybe factor out to a dedicated class...
private readonly IDictionary<System.Type, IQueryable> m_SupportedPools =
    new Dictionary<System.Type, IQueryable>();

// add this queryable, note that type inference works here
public void AddToPool<T>(IQueryable<T> p_Queryable)
{
    m_SupportedPools.Add(typeof(T), p_Queryable);
}

public IQueryable<T> GetPool<T>()
{
    IQueryable t_Set = null;  
    if (m_SupportedQueries.TryGetValue(typeof(T), out t_Set)) {
        return t_Set as IQueryable<T>;
    } else {
        return null;
    }
}