支持任何模型的通用 Web Api 控制器

Question

是否可以有一个通用的 web api 来支持您项目中的任何模型？

class BaseApiController<T> :ApiController
{
    private IRepository<T> _repository;

    // inject repository

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

    public virtual T Get(int id)
    {
       return _repositry.Get(id);
    }

    public virtual void Post(T item)
    {
       _repository.Save(item);
    }
    // etc...
}

class FooApiController : BaseApiController<Foo>
{
   //..

}

class BarApiController : BaseApiController<Bar>
{
   //..
}

这是一个好方法吗？

毕竟，我只是在重复 CRUD 方法？我可以使用这个基类为我做这项工作吗？

这样好吗？你会这样做吗？有更好的主意吗？

Answer 1

我为一个小项目做这件事是为了让一些东西启动并运行以向客户演示。一旦我了解了业务规则、验证和其他注意事项的细节，我最终不得不从我的基类中重写 CRUD 方法，因此它没有成为长期实现。

我遇到了路由问题，因为并非所有东西都使用相同类型的 ID（我使用的是现有系统）。一些表有int 主键，一些有strings 和其他有guids。

我最终也遇到了问题。最后，虽然我第一次做的时候看起来很流畅，但在现实世界的实现中实际使用它被证明是另一回事，根本没有让我走得更远。

Answer 2

这绝对是可能的。我以前从来没有理由这样做，但如果它适合你的情况，那应该是好的。

如果您的所有模型都可以以完全相同的方式保存和检索，那么也许它们应该都在同一个控制器中？

Answer 3

 public class GenericApiController<TEntity> : BaseApiController
    where TEntity : class, new()
{
    [HttpGet]
    [Route("api/{Controller}/{id}")]       
    public IHttpActionResult Get(int id)
    {
        try
        {
            var entity = db.Set<TEntity>().Find(id);
            if(entity==null)
            {
                return NotFound();
            }
            return Ok(entity);

        }
        catch(Exception ex)
        {
            return InternalServerError(ex);
        }
    }

    [HttpGet]
    [Route("api/{Controller}")]
    public IHttpActionResult Post(TEntity entity)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        try
        {
            var primaryKeyValue = GetPrimaryKeyValue(entity);
            var primaryKeyName = GetPrimaryKeyName(entity);
            var existing = db.Set<TEntity>().Find(primaryKeyValue);
            ReflectionHelper.Copy(entity, existing, primaryKeyName);
            db.Entry<TEntity>(existing).State = EntityState.Modified;
            db.SaveChanges();
            return Ok(entity);
        }
        catch (Exception ex)
        {
            return InternalServerError(ex);
        }
    }

    [HttpGet]
    [Route("api/{Controller}/{id}")]
    public IHttpActionResult Put(int id, TEntity entity)
    {
        try
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var existing = db.Set<TEntity>().Find(id);
            if (entity == null)
            {
                return NotFound();
            }
            ReflectionHelper.Copy(entity, existing);
            db.SaveChanges();
            return Ok(entity);
        }
        catch (Exception ex)
        {
            return InternalServerError(ex);
        }
    }

    [HttpDelete]
    [Route("api/{Controller}/{id}")]
    public IHttpActionResult Delete(int id)
    {
        try
        {
            var entity = db.Set<TEntity>().Find(id);
            if(entity==null)
            {
                return NotFound();
            }
            db.Set<TEntity>().Remove(entity);
            db.SaveChanges();
            return Ok();
        }
        catch (Exception ex)
        {
            return InternalServerError(ex);
        }
    }

    protected internal int GetPrimaryKeyValue(TEntity entity)
    {
        return ReflectionHelper.GetPrimaryKeyValue(entity);
    }

    protected internal string GetPrimaryKeyName(TEntity entity)
    {
        return ReflectionHelper.GetPrimaryKeyName(entity);
    }

    protected internal bool Exists(int id)
    {
        return db.Set<TEntity>().Find(id) != null;
    }
}

Answer 4

只要您处理存储库中的所有繁重工作，这没有什么问题。您可能希望在基本控制器中包装/处理模型状态异常。

我实际上正在为一个用户可以定义自己的实体和 API 的大型项目做类似的事情 - 即：一个用户可能想要拥有用户和帐户，而另一个用户可能想要跟踪汽车和其他任何东西。它们都使用相同的内部控制器，但它们都有自己的端点。

不确定我们的代码对您有多大用处，因为我们不使用泛型（每个对象都作为元数据进行维护，并作为 JObject 字典来回操作/传递），但这里有一些代码可以让您了解我们的内容正在做并且可能提供思考的食物：

[POST("{primaryEntity}", RouteName = "PostPrimary")]
public async Task<HttpResponseMessage> CreatePrimary(string primaryEntity, JObject entity)
{
   // first find out which params are necessary to accept the request based on the entity's mapped metadata type
   OperationalParams paramsForRequest = GetOperationalParams(primaryEntity, DatasetOperationalEntityIntentIntentType.POST);

   // map the passed values to the expected params and the intent that is in use
   IDictionary<string, object> objValues = MapAndValidateProperties(paramsForRequest.EntityModel, paramsForRequest.IntentModel, entity);

   // get the results back from the service and return the data to the client.
   QueryResults results = await paramsForRequest.ClientService.CreatePrimaryEntity(paramsForRequest.EntityModel, objValues, entity, paramsForRequest.IntentModel);
        return HttpResponseMessageFromQueryResults(primaryEntity, results);

}

Answer 5

如果您有预定义的设计时类，例如从 EF 模型或 Code First 生成的类，那么这对您的系统来说太复杂了。如果您没有预定义的类（例如在我的项目中在运行时生成数据实体类），这将非常有用。

我的解决方案（尚未正确实现）是创建自定义 IHttpControllerSelector，它为所有请求选择我的通用控制器，我可以根据请求路径通过反射设置通用参数将控制器的描述符类型从通用设置为具体。

http://entityrepository.codeplex.com/ 也是一个很好的起点（我在 stackoverflow 的某个地方找到了这个）

Answer 6

正如其他人所说，您所做的绝对是可能的。但是对于存储库依赖项，您应该使用依赖项注入。我的典型控制器（Api 或 MVC）如下。

public class PatientCategoryApiController : ApiController
{

    private IEntityRepository<PatientCategory, short> m_Repository;
    public PatientCategoryApiController(IEntityRepository<PatientCategory, short> repository)
    {
        if (repository == null)
            throw new ArgumentNullException("entitiesContext is null");

        m_Repository = repository;
    }
}

这是典型的构造函数注入模式。您需要对 DI 和 NInject 或 Autofac 等容器有充分的了解。如果您不了解 DI，那么您还有很长的路要走。但这是一个很好的方法。看看这本书。 https://www.manning.com/books/dependency-injection-in-dot-net