如何通过创建像ASMX Web服务的实例来使用WebAPI

Question

I have Asp.NET WebApi as business layer. I want to call it's methods by simply calling business controllers. something like this: (but i'm not able to add this webapi like a service reference)

Business.API.UserController Users = new Business.API.UserController();
Users.GetAllUser();

previously i was working with WCF web services where i was able to create an instance of web service just by adding it through "Add Service References" and setting some Endpoints. I can't do that in WebAPI (I think). i have read so many article about it but most of them was about calling it's method by HttpRequest. in this way :

using (var client = new HttpClient())    
{    
    client.BaseAddress = new Uri("http://localhost:38104/");
    client.DefaultRequestHeaders.Accept.Clear();    
    HttpResponseMessage response;    
    response = await client.GetAsync("api/Weather");    
    if (response.IsSuccessStatusCode)    
    {    
        WeatherClient[] reports = await response.Content.ReadAsAsync<WeatherClient[]>();                   
     }    
}    

I think it's a ridiculous using of an web service. am i wrong or there is something wrong with me ?

Answer 1

While there is nothing wrong with you, that is also not a ridiculous way of using a web service. In fact; its the only way to use a web service; WCF hid that code for you.

_{Disclaimer: There are other .NET classes and libraries that perform HTTP requests and may have a simpler API, but nothing that will hide it as a class like WCF}

WCF services publish metadata about themselves, which is why "Service References" works. Web API does not have a similar concept, you have to manually do the HTTP request. You can of course wrap that code into some generic functions for reuse.

With the right helper methods, you can get close to a "RPC" interface, just needing to pass in each method's endpoint instead of a name.

Answer 2

It's best for classes to depend on interfaces rather than directly instantiating an HttpClient . I've seen applications that did this correctly with WCF services - depending on service interfaces - but then for Web APIs they throw away abstraction and directly incorporate Http requests.

Within your application you can still define an interface representing some service so that the implementation - Web API, mock, something else - is abstracted.

For example, you might depend on this interface

public interface IFooService
{
    FooDto GetFoo(Guid id);
    List<FooDto> GetAllFoos();
    Guid InsertFoo(FooInsertDto foo);
    void UpdateFoo(FooDto updating);
    void DeleteFoo(Guid id);
}

and use this implementation:

public class FooServiceClient : IFooService
{
    private readonly RestClient _restClient;

    public FooServiceClient(string baseUrl)
    {
        _restClient = new RestClient(baseUrl.TrimEnd('/'));
    }

    public FooDto GetFoo(Guid id)
    {
        var request = new RestRequest($"api/foo/get{id}", Method.GET);
        var foo = _restClient.Execute<FooDto>(request).Data;
        return foo;
    }

    public List<FooDto> GetAllFoos()
    {
        var request = new RestRequest("api/foo/getall", Method.GET);
        var foos = _restClient.Execute<List<FooDto>>(request).Data;
        return foos;
    }

    public Guid InsertFoo(FooInsertDto foo)
    {
        var request = new RestRequest("api/foo/insert", Method.POST)
            { RequestFormat = DataFormat.Json};
        request.AddBody(foo);
        return _restClient.Execute<Guid>(request).Data;
    }

    public void UpdateFoo(FooDto updating)
    {
        var request = new RestRequest("api/foo/update", Method.POST)
        { RequestFormat = DataFormat.Json };
        request.AddBody(updating);
        _restClient.Execute(request);
    }

    public void DeleteFoo(Guid id)
    {
        var request = new RestRequest("api/foo/delete", Method.POST)
        { RequestFormat = DataFormat.Json };
        request.AddBody(id);
        _restClient.Execute(request);
    }
}

This also demonstrates the use of RestSharp . It's not recommended to create and dispose an HttpClient for each use. RestSharp helps manage that and provides methods to simplify sending requests and reading responses.