[C#] HttpClient와 WebClient 사이에서 결정

아마도 당신은 다른 방식으로 문제에 대해 생각할 수 있습니다. WebClient와 HttpClient같은 것을 본질적으로 다른 구현이다. 권장 사항은 응용 프로그램 전체 에서 IoC 컨테이너로 Dependency Injection 패턴 을 구현하는 것 입니다. 저수준 HTTP 전송보다 추상화 수준이 높은 클라이언트 인터페이스를 구성해야합니다. 당신은 모두를 사용하여 구체적인 클래스를 쓸 수 있습니다 및 다음 설정을 통해 구현을 주입하는 IoC 컨테이너를 사용합니다.WebClientHttpClient

이것이 당신이 할 수있는 것입니다 것은 사이를 전환하는 것 HttpClient하고 WebClient쉽게 그래서 당신은 프로덕션 환경에서 객관적으로 테스트 할 수 있음.

따라서 다음과 같은 질문이 있습니다.

.Net 4.5로 업그레이드하면 HttpClient가 더 나은 디자인 선택입니까?

실제로 IoC 컨테이너를 사용하여 두 클라이언트 구현간에 전환하여 객관적으로 답변 할 수 있습니다. 다음은 HttpClientor에 대한 세부 정보가 포함되지 않은 인터페이스 예 WebClient입니다.

/// <summary>
/// Dependency Injection abstraction for rest clients. 
/// </summary>
public interface IClient
{
    /// <summary>
    /// Adapter for serialization/deserialization of http body data
    /// </summary>
    ISerializationAdapter SerializationAdapter { get; }

    /// <summary>
    /// Sends a strongly typed request to the server and waits for a strongly typed response
    /// </summary>
    /// <typeparam name="TResponseBody">The expected type of the response body</typeparam>
    /// <typeparam name="TRequestBody">The type of the request body if specified</typeparam>
    /// <param name="request">The request that will be translated to a http request</param>
    /// <returns></returns>
    Task<Response<TResponseBody>> SendAsync<TResponseBody, TRequestBody>(Request<TRequestBody> request);

    /// <summary>
    /// Default headers to be sent with http requests
    /// </summary>
    IHeadersCollection DefaultRequestHeaders { get; }

    /// <summary>
    /// Default timeout for http requests
    /// </summary>
    TimeSpan Timeout { get; set; }

    /// <summary>
    /// Base Uri for the client. Any resources specified on requests will be relative to this.
    /// </summary>
    Uri BaseUri { get; set; }

    /// <summary>
    /// Name of the client
    /// </summary>
    string Name { get; }
}

public class Request<TRequestBody>
{
    #region Public Properties
    public IHeadersCollection Headers { get; }
    public Uri Resource { get; set; }
    public HttpRequestMethod HttpRequestMethod { get; set; }
    public TRequestBody Body { get; set; }
    public CancellationToken CancellationToken { get; set; }
    public string CustomHttpRequestMethod { get; set; }
    #endregion

    public Request(Uri resource,
        TRequestBody body,
        IHeadersCollection headers,
        HttpRequestMethod httpRequestMethod,
        IClient client,
        CancellationToken cancellationToken)
    {
        Body = body;
        Headers = headers;
        Resource = resource;
        HttpRequestMethod = httpRequestMethod;
        CancellationToken = cancellationToken;

        if (Headers == null) Headers = new RequestHeadersCollection();

        var defaultRequestHeaders = client?.DefaultRequestHeaders;
        if (defaultRequestHeaders == null) return;

        foreach (var kvp in defaultRequestHeaders)
        {
            Headers.Add(kvp);
        }
    }
}

public abstract class Response<TResponseBody> : Response
{
    #region Public Properties
    public virtual TResponseBody Body { get; }

    #endregion

    #region Constructors
    /// <summary>
    /// Only used for mocking or other inheritance
    /// </summary>
    protected Response() : base()
    {
    }

    protected Response(
    IHeadersCollection headersCollection,
    int statusCode,
    HttpRequestMethod httpRequestMethod,
    byte[] responseData,
    TResponseBody body,
    Uri requestUri
    ) : base(
        headersCollection,
        statusCode,
        httpRequestMethod,
        responseData,
        requestUri)
    {
        Body = body;
    }

    public static implicit operator TResponseBody(Response<TResponseBody> readResult)
    {
        return readResult.Body;
    }
    #endregion
}

public abstract class Response
{
    #region Fields
    private readonly byte[] _responseData;
    #endregion

    #region Public Properties
    public virtual int StatusCode { get; }
    public virtual IHeadersCollection Headers { get; }
    public virtual HttpRequestMethod HttpRequestMethod { get; }
    public abstract bool IsSuccess { get; }
    public virtual Uri RequestUri { get; }
    #endregion

    #region Constructor
    /// <summary>
    /// Only used for mocking or other inheritance
    /// </summary>
    protected Response()
    {
    }

    protected Response
    (
    IHeadersCollection headersCollection,
    int statusCode,
    HttpRequestMethod httpRequestMethod,
    byte[] responseData,
    Uri requestUri
    )
    {
        StatusCode = statusCode;
        Headers = headersCollection;
        HttpRequestMethod = httpRequestMethod;
        RequestUri = requestUri;
        _responseData = responseData;
    }
    #endregion

    #region Public Methods
    public virtual byte[] GetResponseData()
    {
        return _responseData;
    }
    #endregion
}

전체 코드

HttpClient 구현

구현에서 비동기 적으로 실행 Task.Run하는 데 사용할 수 있습니다 WebClient.

Dependency Injection은 잘 수행되면 낮은 수준의 의사 결정을 미리 내릴 때 발생하는 문제를 완화하는 데 도움이됩니다. 궁극적으로 정답을 알 수있는 유일한 방법은 실제 환경에서 가장 효과적인 방법을 확인하는 것입니다. 그것은 그 꽤 가능성이 WebClient일부 고객을 위해 더 잘 작동 할 수 있으며, HttpClient다른 사람을 위해 잘 작동 할 수 있습니다. 이것이 추상화가 중요한 이유입니다. 즉, 앱의 기본 디자인을 변경하지 않고도 코드를 신속하게 교체하거나 구성으로 변경할 수 있습니다.

답변