用抽象类型实现抽象类

Question

我有一个基础抽象类，它接受来自抽象类的类型，我正用头撞墙，试图找出如何正确实现它。

基类：

public abstract class ApiService<TRequest, TResponse>
    where TRequest : ApiRequest
    where TResponse : ApiResponse
{
    public abstract TResponse Execute(TRequest Request);
}

ApiRequest 类：

public abstract class ApiRequest
{

}

ApiResponse 类：

public abstract class ApiResponse
{
    public bool Succeeded { get; set; }

}

我创建了一个 TestService 类来尝试解决这个问题，但这些概念对我来说并没有结合在一起：

public class TestService : ApiService<ApiRequest, ApiResponse>
{
    public override ApiResponse Execute(ApiRequest Request)
    {
        ApiResponse response;

        return (response);
    }

您能提供的任何帮助将不胜感激，并帮助我进一步了解抽象类！ 谢谢！

所以我的问题是：我不知道如何在 Execute 方法中实现 ApiResponse，因为您无法实例化抽象类。

Answer 1

泛型和多态化很好，但它必须在某个时候停止。 在您的情况下，您有一个很好的 API 接口，很明显您传递了一个TRequest并TResponse接收了一个TResponse 。

您应该添加的是如何对待特定情况。 添加一层IRequestHander<TRequest,TResult> ，它将知道如何从特定的Request创建特定的Result 。

然后使用Factory设计模式，您的 API 函数将调用工厂以获取适合其获得的请求的特定处理程序。 它将执行RequestHander并返回它从中获得的Response 。

public class SpecificRequestA : ApiRequest {}
public class SpecificResponseA : ApiResponse{}

public interface IRequestHander<TRequest,TResponse>
    where TRequest : ApiRequest
    where TResponse : ApiResponse
{
    TResponse Exeute(TRequest request);
}

public class SpecificRequestHandlerA : IRequestHander<SpecificRequestA,SpecificResponseA>
{
    SpecificResponseA Execute(SpecificRequestA request)
    {
        //create the new response out of the given request. Here you know exactly on what you are working :)
    }
}

然后添加工厂。

还可以考虑将请求实现为Request<TResponse> - 看看它是否更适合您的情况

我建议研究依赖注入和 DI 容器（如 Castle、Ninject、Unity、Simple Injector）来负责初始化。

Answer 2

我在 ac# MVC UI 层中使用了以下 ApiClient 类：

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Web;
using System.Web.Helpers;
using System.Web.Mvc;

namespace DocumentManager.UI
{
    public class ApiClient<T>
    {
        public ApiClientErrorTypes Error{get;private set;}

        private string baseUri =  @"http://localhost/DocumentManager.WebAPI/";

        public T ApiGet(string requestUrl)
        {
            using (var client = new HttpClient())
            {
                var requestUri = new Uri(baseUri + requestUrl);
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                if (ApiAuthToken.token != null)
                {
                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", ApiAuthToken.token.ToString());
                }
                var response = client.GetAsync(requestUri).Result;
                string contentString = response.Content.ReadAsStringAsync().Result;
                if (response.IsSuccessStatusCode)
                {
                    T result = JsonConvert.DeserializeObject<T>(contentString);
                    return result;
                }
                if (int.Parse(response.StatusCode.ToString()) > 400 && int.Parse(response.StatusCode.ToString()) <= 499)
                    Error = ApiClientErrorTypes.UnAuthorised;
                else
                    Error = ApiClientErrorTypes.Technical;
                return default(T);
            }
        }

        public T ApiPost(string requestUrl, HttpContent encodedContent)
        {
            using(var client = new HttpClient())
            {
                var requestUri = new Uri(baseUri + requestUrl);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                if (ApiAuthToken.token != null)
                {
                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", ApiAuthToken.token.ToString());
                }
                var response = client.PostAsync(requestUri, encodedContent).Result;
                string contentString = response.Content.ReadAsStringAsync().Result;
                if (response.IsSuccessStatusCode)
                {
                    T result = JsonConvert.DeserializeObject<T>(contentString);
                    return result;
                }
                if (int.Parse(response.StatusCode.ToString()) > 400 && int.Parse(response.StatusCode.ToString()) <= 499)
                    Error = ApiClientErrorTypes.UnAuthorised;
                else
                    Error = ApiClientErrorTypes.Technical;
                return default(T);
            }
        }

        public bool ApiPostBool(string requestUrl, HttpContent encodedContent)
        {
            using (var client = new HttpClient())
            {
                var requestUri = new Uri(baseUri + requestUrl);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                if (ApiAuthToken.token != null)
                {
                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", ApiAuthToken.token.ToString());
                }
                var response = client.PostAsync(requestUri, encodedContent).Result;
                string contentString = response.Content.ReadAsStringAsync().Result;
                if (response.IsSuccessStatusCode)
                {
                    return true;
                }
                return false;
            }
        }
    }
}

我从 MVC 控制器以下列方式调用它：

var apiClient = new ApiClient<Document>();
var doc = apiClient.ApiGet("api/document/get/" + id);
if (doc != null)
{
    //do stuff here
}

我使用以下 Web API 层方法返回此项目

namespace DocumentManager.WebApi.Controllers
{
    [RoutePrefix("api/document")]
    public class DocumentController : BaseController
    {
        [Route("get/{id}")]
        public IHttpActionResult Get(int id)
        {
            return Ok(DACDocument.Read(new DataContext(),id));
        }
    }
}

这背后有一个实体框架数据层（DAC ...）

我使用这种架构结构的原因是我希望多个 MVC UI 前端应用程序绑定到 API 后端。

解决方案中的项目是数据（类库）API（Web API）UI（Web MVC）

如果这有帮助，请标记为答案！