Fatal编程技术网
  • csharp/
  • C# 用抽象类型实现抽象类

C# 用抽象类型实现抽象类

c# generics inheritance

C# 用抽象类型实现抽象类,c#,generics,inheritance,abstract-class,C#,Generics,Inheritance,Abstract Class,我有一个基本的抽象类，它接受来自抽象类的类型，我正在努力找出如何正确实现它 基类： public abstract class ApiService<TRequest, TResponse> where TRequest : ApiRequest where TResponse : ApiResponse { public abstract TResponse Execute(TRequest Request); } ApiResponse类： public

我有一个基本的抽象类，它接受来自抽象类的类型，我正在努力找出如何正确实现它

基类：

public abstract class ApiService<TRequest, TResponse>
    where TRequest : ApiRequest
    where TResponse : ApiResponse
{
    public abstract TResponse Execute(TRequest Request);
}
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);
    }

公共类TestService:ApiService
{
公共覆盖ApiResponse执行（APIRESQUEST）
{
API反应；
返回（响应）；
}
非常感谢您提供的任何帮助，帮助我进一步理解抽象类！谢谢

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

泛型和多态性很好，但它必须在某个点停止。在你的例子中，你有一个很好的API接口，在这里你可以清楚地传递一个
TRequest
并接收一个
TRes用ponse

您应该添加的是如何处理特定案例。添加一层
IRequestHander
，它将知道如何从特定的
请求创建特定的
结果

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


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 :)
    }
}



public类SpecificRequestA:ApiRequest{}
公共类SpecificResponseA:ApiResponse{}
公共接口IRequestHander
哪里有TRequest:ApiRequest
哪里有响应：ApiResponse
{
TResponse Exeute（TRequest请求）；
}
公共类SpecificRequestHandlerA:IRequestHander
{
SpecificResponseA执行（SpecificRequestA请求）
{
//根据给定的请求创建新的响应。在这里，您可以确切地了解您正在工作的内容：）
}
}


然后添加工厂

还可以考虑将请求实现为
请求
——看看它是否更适合您的情况

我建议研究依赖注入和DI容器（如Castle、Ninject、Unity、Simple Injector）来

负责初始化。
泛型和多态性很好，但它必须在某个点停止。在您的情况下，您有一个很好的API接口，可以清楚地看到您传递了一个
TRequest
，并收到了一个
treresponse

您应该添加的是如何处理特定案例。添加一层
IRequestHander
，它将知道如何从特定的
请求创建特定的
结果

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


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 :)
    }
}



public类SpecificRequestA:ApiRequest{}
公共类SpecificResponseA:ApiResponse{}
公共接口IRequestHander
哪里有TRequest:ApiRequest
哪里有响应：ApiResponse
{
TResponse Exeute（TRequest请求）；
}
公共类SpecificRequestHandlerA:IRequestHander
{
SpecificResponseA执行（SpecificRequestA请求）
{
//根据给定的请求创建新的响应。在这里，您可以确切地了解您正在工作的内容：）
}
}


然后添加工厂

还可以考虑将请求实现为
请求
——看看它是否更适合您的情况

我建议研究依赖注入和DI容器（如Castle、Ninject、Unity、Simple Injector）来

负责初始化。
我在c#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;
            }
        }
    }
}


这背后有一个entityframework数据层（DAC…）

我使用这种体系结构的原因是我希望多个MVC UI前端应用程序与API后端相结合

解决方案中的项目是
数据（类库）
API（网络API）
用户界面（Web MVC）


如果这有帮助，请标记为答案！
我在c#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;
            }
        }
    }
}


这背后有一个entityframework数据层（DAC…）

我使用这种体系结构的原因是我希望多个MVC UI前端应用程序与API后端相结合

解决方案中的项目是
数据（类库）
API（网络API）
用户界面（Web MVC）


如果这有帮助，请标记为answer！
那么您提供的代码有什么问题？我不知道如何在Execute方法中实现ApiResponse，因为您无法实例化抽象类。我假设
TestService
将用于处理
APIRESQUEST
和
ApiResponse的具体派生类？例如
TestService:ApiService
？那么您提供的代码有什么问题？我不知道如何在Execute方法中实现ApiResponse，因为您无法实例化抽象类。我假设
TestService
将用于处理
apirest
和
ApiRes的具体派生类ponse
？例如
TestService:ApiService
？

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));
        }
    }
}