Comment consommer un ASP.NET Core WebAPI en C# UWP application?

Je suis en train d'essayer de comprendre comment il est possible de consommer un ASP.NET Core WebAPI au sein d'une UWP/UAP application.
J'ai pensé que je serait possible de consommer de la WebAPI similaire à la consommation d'un Service WCF, mais je n'ai rien trouvé à ce sujet encore.

De plus j'ai essayé d'installer Microsoft.AspNet.WebApi.Core, mais n'avait pas de succès car il n'est pas compatible avec l'UAP (Version=V10.0).

Je suis un peu perdu maintenant. Peut-être que quelqu'un pourrait me donner un indice comment je pourrais utiliser la WebApi au sein de l'UWP application.

ASP.NET Core WebAPI n'est pas comme de la WCF. Que c'est il ne prévoit pas de norme façons de consommer comme WCF, il n'est pas généré automatiquement client pour la consommation de WebAPI points de terminaison. ASP.NET utilise le protocole HTTP comme protocole, vous pouvez utiliser le client web ou quelque chose de similaire pour envoyer des requêtes HTTP et de l'analyse des réponses de JSON ou XML pour les objets et faites-vous de la logique métier.

OriginalL'auteur Chris | 2016-07-11

  1. 7

    C'est la même chose que de consommer un appel d'API. Utilisez simplement le HttpClient classe d'invoquer le point de terminaison et de gérer la réponse, il n'y a pas de différence dans le comportement attendu.

    Imaginez que vous avez un ASP.NET de Base de l'API Web point de terminaison définis comme ceci:

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

    En supposant que cela est hébergé sur `localhost:5000', vous pouvez effectuer les opérations suivantes:

    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!' }"
        }
    }
}

    En outre, vous pouvez désérialiser cela comme un objet fortement typé utilisation Newtonsoft.Json. J'ai un exemple de mon UWP app de faire cette chose très ici.

    je vous remercie beaucoup. C'est l'explication que j'ai besoin. Hier, j'ai déjà trouvé une explication sur la façon de le faire dans UWP et je pense que mon plus gros problème était de ne pas savoir qu'il y a cette classe HttpClient disponible dans WinRT. Je pensais que j'avais pour référence ASP.NET de Base à mon UWP application en quelque sorte.
    J'ai un peu hors sujet, la question de l'extrait de code suivant: mission de service public<GreetingResult> Salutation() => la Tâche.FromResult(nouveau GreetingResult { Message = "Bonjour le monde!" });. Je n'ai jamais vu ce genre d'assigner une Tâche à un délégué (?). Qu'est-ce que ce Salut()? Excuse cette question stupide.
    J'espère que vous aurez upvote et accepter les réponses. Greeting() est une méthode, c'est le C# 6 syntaxe simple, les membres peuvent être définis comme des expressions à l'aide de la goes to opérateur, c'est à dire; =>.

    OriginalL'auteur David Pine

  2. 5

    Je vais ajouter plus d'information:

    Meilleure façon de consommer de l'Api Web dans UWP est d'utiliser HttpClient comme mentionné avant.

    Voici quelques exemples, je pense, pourrait être utile.

    La bonne pratique est de créer MobileServiceClient classe où vous pouvez recueillir toutes les opérations que vous pouvez effectuer sur le Web Api de niveau:

    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
}

    Veuillez noter qu'avec cette application, vous pouvez partager le code dans le futur si vous décidez par exemple de soutenir d'autres platfroms (comme Xamarin Android ou iOS).
    J'espère que cela va vous aider.

    D'où vient JsonConvert venir frome?
    Json.NET est un populaire, haute performance de JSON cadre .NET: nuget.org/packages/newtonsoft.json (UWP).
    Merci, je n'étais pas sûr Newtonsoft.Json est prêt pour le Cœur encore.

    OriginalL'auteur Daniel Krzyczkowski

  3. 3

    David Pins réponse est assez bon si vous voulez faire tous les trucs manuellement et/ou vous n'utilisez pas de swagger.

    Si vous utilisez Swagger (c'est à dire Swashbuckle Swagger 6.0 pour ASP.NET de Base) pour décrire votre API RESTful et de générer de la documentation, vous pouvez utiliser le style de fichier de définition (swagger.json) pour générer un Client Rest. Un tel outil est AutoRest, créé par l'Azur de l'équipe. Il faudra aussi Microsoft.Le repos.ClientRuntime qui prend déjà en charge DotNet.

    Je ne sais pas si il fonctionne avec ASP.NET Core RTM encore, mais il y avait résolu/fermé questions en indiquant qu'il avait le soutien pour les versions précédentes et les bêtas fusionné.

    Package NuGet Liens

    OriginalL'auteur Tseng