好好从语文上 理解 模版 和 约束 两个词语。
可以你说的那样写，甚至你写object、dynamic都可以。
你怎么能 让 其 具备 上面两个词的 意义呢 —— 我要调用子类函数，如果是object或者父类怎么办，是不是要妥妥的麻烦呢？至于约束就更不必提了，且约束有很多种约束，举个例子什么是约束 ——
意义：概念->工具->使用；
虽然有了手动档，但我设想要有一种手自一体的，于是我厂的车子就是手自一体的，你使用我厂的车子就这么用了。

你说的这个场景的确都可以，根据实际需求选择，使用泛型方法，调用端少了强转，语意会比较清楚。本来泛型就是语法糖而已。

约束你的 T，只能是某个类或者这个类的派生类。
比如 MyClass<T> 的约束为 Person。那么你写代码的时候 MyClass<Person> bbb = new MyClass<Person> 是可以的。但是你要写 MyClass<string> bbb 就会报错！

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.Migrations;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using WebApiHost.Core;
using WebApiHost.Entities;

namespace WebApiHost.Repositories
{
[ExcludeFromCodeCoverage]
public abstract class RepositoryBase<T> where T : class
{
protected readonly IDbSet<T> dbset;
protected LoyaltyServiceContext dataContext;

    protected RepositoryBase(IDatabaseFactory databaseFactory)
    {
        DatabaseFactory = databaseFactory;
        dbset = DataContext.Set<T>();
    }

    protected IDatabaseFactory DatabaseFactory { get; }

    protected LoyaltyServiceContext DataContext
    {
        get { return dataContext ?? (dataContext = DatabaseFactory.Get()); }
    }

    public virtual void Add(T entity)
    {
        dbset.Add(entity);
    }

    public bool Exist(Expression<Func<T, bool>> where)
    {
        return dbset.AsQueryable().Any(where);
    }

    public virtual void AddRange(T[] entities)
    {
        DataContext.Set<T>().AddRange(entities);
    }
    public virtual void AddOrUpdateRange(T[] entities)
    {
        dbset.AddOrUpdate(entities);
    }

    public virtual IQueryable<T> AsQueryable()
    {
        return dbset.AsQueryable();
    }

    public bool RefreshEntityInContext(T entity)
    {
        var objContext = ((IObjectContextAdapter)dataContext).ObjectContext;
        var objSet = objContext.CreateObjectSet<T>();
        var entityKey = objContext.CreateEntityKey(objSet.EntitySet.Name, entity);

        object foundEntity;
        var exists = objContext.TryGetObjectByKey(entityKey, out foundEntity);

        if (exists)
        {
            objContext.Detach(foundEntity);
        }

        dbset.Attach(entity);

        return (exists);
    }


    public virtual void Update(T entity)
    {
        RefreshEntityInContext(entity);
        dbset.Attach(entity);
        dataContext.Entry(entity).State = EntityState.Modified;
    }

    public virtual void Delete(T entity)
    {
        dbset.Remove(entity);
    }

    public virtual void Delete(Expression<Func<T, bool>> where)
    {
        var objects = dbset.Where(where).AsEnumerable();
        foreach (var obj in objects)
            dbset.Remove(obj);
    }

    public virtual T GetById(int id)
    {
        return dbset.Find(id);
    }
    public virtual T GetById(Guid id)
    {
        return dbset.Find(id);
    }

    public virtual T GetById(string id)
    {
        return dbset.Find(id);
    }

    public virtual IEnumerable<T> GetAll()
    {
        return dbset.ToList();
    }

    public virtual IEnumerable<T> GetMany(Expression<Func<T, bool>> where)
    {
        return dbset.Where(where).ToList();
    }

    public T Get(Expression<Func<T, bool>> where)
    {
        return dbset.FirstOrDefault(where);
    }

    public async Task<T> GetByIdAsync(int id)
    {
        return await dataContext.Set<T>().FindAsync(id);
    }
    public async Task<T> GetByIdAsync(string id)
    {
        return await dataContext.Set<T>().FindAsync(id);
    }

    public virtual async Task<T> GetAsync(Expression<Func<T, bool>> where)
    {
        return await dataContext.Set<T>().AsNoTracking().Where(where).SingleOrDefaultAsync();
    }

    public async Task<IList<T>> GetAllAsync()
    {
        return await dataContext.Set<T>().AsNoTracking().ToListAsync();
    }

    public virtual async Task<IList<T>> GetManyAsync(Expression<Func<T, bool>> where)
    {
        return await dataContext.Set<T>().AsNoTracking().Where(where).ToListAsync();
    }
}

}