Jak wykorzystać podstawowy interfejs sieciowy ASP.NET w aplikacji C# UWP?

Question

Próbuję zrozumieć, w jaki sposób możliwe jest korzystanie z interfejsu ASP.NET Core WebAPI w aplikacji UWP/UAP. Pomyślałem, że będę mógł skonsumować interfejs WebAPI podobny do korzystania z usługi WCF, ale nie znalazłem jeszcze nic na ten temat.

Ponadto próbowałem zainstalować Microsoft.AspNet.WebApi.Core, ale nie odniosłem sukcesu, ponieważ nie jest zgodny z UAP (wersja = V10.0).

Jestem trochę zagubiony. Może ktoś mógłby dać mi wskazówkę, jak mogę korzystać z WebApi w aplikacji UWP.

Answer 1

Jest to to samo, co korzystanie z dowolnej funkcji API. Po prostu użyj klasy HttpClient, aby wywołać punkt końcowy i obsłużyć odpowiedź, nie ma różnicy w oczekiwanym zachowaniu.

Wyobraź sobie, że masz Web API końcowy ASP.NET rdzenia zdefiniowana tak:

public class StackoverflowController : Controller 
{  
    // I wanted to exemplify async capabilities. 
    // You'd use async/await for getting database values, etc. 
    [ 
     HttpGet, 
     AllowAnonymous, 
     Route("api/greeting") 
    ] 
    public Task<GreetingResult> Greeting() => 
     Task.FromResult(new GreetingResult { Message = "Hello world!" }); 
} 

public class GreetingResult 
{ 
    public string Message { get; set; } 
} 

Zakładając ten gościł na `localhost: 5000' można wykonać następujące czynności:

public class Consumer 
{ 
    public async Task<string> GetGreetingAsync() 
    { 
     using (var client = new HttpClient()) 
     { 
      var response = 
       await client.GetStringAsync("http://localhost:5000/api/greeting"); 
      // The response object is a string that looks like this: 
      // "{ message: 'Hello world!' }" 
     } 
    } 
} 

Dodatkowo, możesz deserializować to jako mocno wpisane użycie obiektu Newtonsoft.Json. Mam przykład mojej aplikacji UWP robiącej to samo, here.

Answer 2

Odpowiedź Davida Pinesa jest wystarczająco dobra, jeśli chcesz zrobić wszystkie rzeczy ręcznie i/lub nie używasz zbzikowania.

Jeśli użyjesz Swagger (tj. Swashbuckle Swagger 6.0 dla ASP.NET Core) do opisania swojego RESTful API i wygenerowania dla niego dokumentacji, możesz użyć pliku definicji swagger (swagger.json), aby wygenerować klienta odpoczynku. Jednym z takich narzędzi jest AutoRest, stworzony przez zespół Azure. Będzie też wymagać Microsoft.Rest.ClientRuntime, która obsługuje już DotNet.

Nie jestem pewien, czy działa z ASP.NET Core RTM jeszcze, ale były rozwiązane/zamknięte problemy wskazujące, że miał wsparcie dla wcześniejszych wersji i bety połączone z nim.

Nuget Pakiet Linki

• AutoRest
• Client Runtime for Microsoft AutoRest Generated Clients

Answer 3

dodam trochę więcej informacji, że:

Najlepszym sposobem, aby konsumować Web API w UWP jest użycie HttpClient jako wspomniane wcześniej.

Oto kilka przykładów, które mogą być pomocne.

Dobrą praktyką jest stworzenie MobileServiceClient klasy, gdzie można zebrać wszystkie operacje, które można wykonać na poziomie Web API:

public class MobileServiceClient 
{ 
    //access token if you use authentication: 
    private string _accessToken; 
    //address of your Web Api: 
    private string _serviceAddress; 

    //Constructor: 
    public MobileServiceClient(string accessToken, string serviceAddress) 
    { 
     _accessToken = accessToken; 
     _serviceAddress = serviceAddress; 
    } 

//Now you can implement methods that you will invoke to perform selected operation related with Web Api: 

#region Methods 

//You can perform "Get" to retrieve object from the Web Api and then deserialize it (using Json .NET): 

public async Task<SampleClass> GetSampleClass() 
    { 
     SampleClass sampleClass= null; 
     try 
     { 
      using (HttpClient client = new HttpClient()) 
      { 
       client.DefaultRequestHeaders.Add("Authorization", "Bearer " + _accessToken); 
       var data = await client.GetAsync(string.Concat(_serviceAddress, "routeName")); 
       var jsonResponse = await data.Content.ReadAsStringAsync(); 
       if (jsonResponse != null) 
        sampleClass= JsonConvert.DeserializeObject<SampleClass>(jsonResponse); 
       return sampleClass; 
      } 
     } 

     catch (WebException exception) 
     { 
      throw new WebException("An error has occurred while calling GetSampleClass method: " + exception.Message); 
     } 
    } 

//You can perform "Get" to retrieve list of objects and then deserialize it: 

public async Task<List<SampleClass>> GetSampleClassObjects() 
    { 
     List<SampleClass> SampleClassObjectsList = null; 
     try 
     { 
      using (HttpClient client = new HttpClient()) 
      { 
       client.DefaultRequestHeaders.Add("Authorization", "Bearer " + _accessToken); 
       var data = await client.GetAsync(string.Concat(_serviceAddress, "routeName")); 
       var jsonResponse = await data.Content.ReadAsStringAsync(); 
       if (jsonResponse != null) 
        SampleClassObjectsList = JsonConvert.DeserializeObject<List<SampleClass>>(jsonResponse); 
       return SampleClassObjectsList; 
      } 
     } 

     catch (WebException exception) 
     { 
      throw new WebException("An error has occurred while calling GetSampleClassObjects method: " + exception.Message); 
     } 
    } 

//You can also "Post" some object: 

public async Task<bool> PostSomeObject(SampleClass sampleClassObject) 
    { 
     try 
     { 
      using (HttpClient client = new HttpClient()) 
      { 
       var sampleClassObjectJson = JsonConvert.SerializeObject(sampleClassObject); 
       client.DefaultRequestHeaders.Add("Authorization", "Bearer " + _accessToken); 
       var content = new StringContent(sampleClassObjectJson, Encoding.UTF8, "application/json"); 
       HttpResponseMessage response = await client.PostAsync(string.Concat(_serviceAddress + "routeName"), content); 
       if (response.StatusCode == HttpStatusCode.OK) 
        return true; 
       else 
        throw new WebException("An error has occurred while calling PostSomeObject method: " + response.Content); 
      } 
     } 

     catch (WebException exception) 
     { 
      throw new WebException("An error has occurred while calling PostFeedback method: " + exception.Message); 
     } 
    } 
#endregion 
} 

Należy pamiętać, że przy takiej realizacji można udostępnić kod w przyszłości, jeśli Ty decydujesz na przykład do obsługi innych platfromów (takich jak Xamarin Android lub iOS). Mam nadzieję, że to ci pomoże.