1

例如，我有一个简单的 web api，它有一个名为 ParentsController 的控制器，它是一个标准的 WebAPi2 ApiController。它是锅炉板。

在客户端，我创建了一个 Repository Base 类，并在此基础上创建了一个 ParentRepository 类。

ApiRequester：

    public class ApiRequester
{
    readonly Uri _apiServiceBaseAddress;
    readonly String _apiControllerPath;
    readonly Guid _apiKey;

    public ApiRequester(string apiServiceBaseAddress, string apiControllerPath, Guid apiKey)
    {
        _apiServiceBaseAddress = new Uri(apiServiceBaseAddress);
        _apiControllerPath = apiControllerPath;
        _apiKey = apiKey;
    }
    public async Task<T> Get<T>(string queryParameters)
    {
        using (var client = new HttpClient { BaseAddress = _apiServiceBaseAddress })
        {
            //client.Timeout = TimeSpan.FromSeconds(60);
            client.DefaultRequestHeaders.Add("X-APIKey", _apiKey.ToString());

            var response = await client.GetAsync(_apiControllerPath + queryParameters);

            var result = await response.Content.ReadAsAsync<T>();

            return result;
        }
    }

    public async Task<T> Post<T>(string queryParameters, T entity)
    {
        using (var client = new HttpClient { BaseAddress = _apiServiceBaseAddress })
        {
            client.DefaultRequestHeaders.Add("X-APIKey", _apiKey.ToString());
            HttpResponseMessage response = null;

            response = await client.PostAsJsonAsync<T>(_apiControllerPath + queryParameters, entity);

            response.EnsureSuccessStatusCode();
            var result = await response.Content.ReadAsAsync<T>();
            return result;
        }
    }

    public async Task<T> Put<T>(string queryParameters, T entity)
    {
        using (var client = new HttpClient { BaseAddress = _apiServiceBaseAddress })
        {
            client.DefaultRequestHeaders.Add("X-APIKey", _apiKey.ToString());
            var response = await client.PutAsJsonAsync<T>(_apiControllerPath + queryParameters, entity);
            response.EnsureSuccessStatusCode();

            var result = await response.Content.ReadAsAsync<T>();

            return result;
        }
    }

    public async Task Delete(string queryParameters)
    {
        using (var client = new HttpClient { BaseAddress = _apiServiceBaseAddress })
        {
            client.DefaultRequestHeaders.Add("X-APIKey", _apiKey.ToString());

            var response = await client.DeleteAsync(_apiControllerPath + queryParameters);
            response.EnsureSuccessStatusCode();
        }
    }
}

存储库库：

public abstract class RepositoryBase<T> where T : class, IEntity
{
    readonly ApiRequester _requester;

    protected RepositoryBase(string apiBaseUri, string controllerPath, Guid apiKey)
    {
        if (String.IsNullOrWhiteSpace(apiBaseUri))
            throw new ArgumentNullException("apiBaseUri");

        if (apiKey.Equals(default(Guid)))
            throw new ArgumentNullException("apiKey");

        _requester = new ApiRequester(apiBaseUri, controllerPath, apiKey);
    }
    public virtual Task<ICollection<T>> GetAsync(string queryParameters)
    {
        return _requester.Get<ICollection<T>>(queryParameters);
    }

    public virtual Task<T> PostAsync(string queryParameters, T entity)
    {
        return _requester.Post<T>(queryParameters, entity);
    }

    public virtual Task<T> PutAsync(string queryParameters, T entity)
    {
        return _requester.Put<T>(queryParameters, entity);
    }
    public virtual Task DeleteAsync(string queryParameters)
    {
        return _requester.Delete(queryParameters);
    }
}

父存储库：

    public class ParentRepository : RepositoryBase<Parent>
{
    public ChannelRepository(string apiBaseUri, string controllerPath, Guid apiKey)
        : base(apiBaseUri, controllerPath, apiKey)
    { }
}

因此，客户端的消费者可以通过调用从 API 获取父列表，因此：

pRepo = new ParentRepository();
var parents = await pRepo.GetAsync();

// Do something with parent collection.

父实体如下所示：

public class Parent : IEntity
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public Guid ParentId { get; set; }

    public String Name { get; set; }

// Navigation Properties
    public virtual ICollection<Child> Children { get; set; }
}

我想在我的存储库方法中允许的内容类似于以下内容：

pRepo = new ParentRepository();
var parents = await pRepo.GetAsync().Where(p => p.Name == "aName").Include(p => p.Children);

这就是我卡住的地方。

如何在我的 GetAsync() 方法中拦截它，以便我可以构建我的 http 请求？

要获得“Where”子句，我应该创建一个扩展方法吗？就像是：

public static ICollection<TEntity> Where(this ICollection<TEntity> source, Func<TEntity> , bool> predicate)
{
// Do something or not?
}

但是然后呢？

对于“包含”部分，我在这里需要什么，也许是 System.Reflection 中的一些东西来获取子集合属性名称？

再次，如何在我的 GetAsync() 方法中拦截推理？

我知道可能有更简单的方法可以使用重载方法来做我想做的事情，但我喜欢创建类似 linq 的方法的想法。

编辑：

为了清楚我想要什么，我认为我需要使用表达式树（还不确定如何）将我的 linq 表达式转换为 web uri：

所以在我的客户中，我写道：var parents = await pRepo.GetAsync().Where(p => p.Name == "aName").Include(p => p.Children);

并且该表达式被转换为：

GET /api/parents/?name=aName&IncludeChildren=true

然后客户端可以执行 Get 请求。请注意，这应该是我可以在针对任何类型的基于 Web 的 API 构建的任何客户端中使用的东西，不一定需要是 WebAPI。

4

1 回答 1

0

在我（有限的）经验中，Web API 控制器具有用于过滤和排序之类的可选参数，然后将这些参数转换为对数据访问层中存储库类的类似 linq 的请求。它们都不驻留在客户端上，客户端使用查询字符串中的标准 HTTP 约定向 Web API 控制器发出请求，例如：

GET /api/parent?minimumId=5&maximumId=20&orderBy=Name

可选的查询字符串参数可以转换为 Linq 或Dynamic Linq以查询底层 DAL 提供的某种 IQueryable。

您可能不会经常在对 Web API 控制器的请求中看到类似 linq 的行为，因为控制器本质上是面向 HTTP 的，而是倾向于类似 HTTP 的行为。

如果您真的想以类似 Linq 的语法包装对 Web API 控制器的调用，我会考虑使用Dynamic Linq将您的数据（Funcs/Expressions/Strings/etc）转换为 Linq 查询，因为它至少可以让您避免大惊小怪自己的反思。

于 2014-11-14T03:39:52.677 回答