Die Umwandlung der Inhalte von HttpResponseMessage zum Objekt

Meine Frage: Wie mache ich das?

So, ich hatte mich nicht berührt, nichts .Netto in etwa 6 Jahre, bis diese Woche. Es gibt eine Menge, die ich vergessen habe und noch mehr, dass ich nie wusste, und während ich Liebe die Idee der async/await-Schlüsselwörter, ich habe da ein kleines problem die Umsetzung der folgenden Anforderungen für eine client-API-Implementierung:

Die ServerAPI Klasse hat eine Methode für jede der API-Methoden, wobei die entsprechenden Eingabeparameter (z.B. die Methode Login nimmt in einem id und ein password macht den API-Aufruf und gibt das Ergebnis an den Aufrufer).
Ich möchte abstrahieren das JSON so, dass mein API-Methoden liefern den aktuellen Objekts, das Sie abrufen (z.B. die Login oben genannte Methode gibt eine User Objekt mit dem auth-token, uid, etc.)
Einige API-Methoden liefern eine 204 auf Erfolg oder die keinen sinnvollen Inhalt haben (nicht sinnvoll in meinem Anwendungsfall habe ich vielleicht nur die Sorge über Erfolg/Misserfolg), für diese würde ich gerne wieder entweder ein bool (true = Erfolg) oder das status-code.
Ich möchte zu halten das async/await (oder gleichwertig) design, denn es scheint wirklich zu funktionieren gut so weit.
Für einige Methoden, ich muss vielleicht einfach nur wieder die HttpResponseMessage Objekt und lassen Sie die Anrufer beschäftigen.

Das ist ungefähr das, was ich habe, so weit und ich bin nicht sicher, wie man es konform mit den oben genannten, ODER ob ich sogar dieses Recht. Jede Beratung wird geschätzt (flamen, jedoch ist es nicht).

//200 (+User JSON) = success, otherwise APIError JSON
internal async Task<User> Login (string id, string password)
{
    LoginPayload payload = new LoginPayload() { LoginId = id, Password = password};
    var request = NewRequest(HttpMethod.Post, "login");
    JsonPayload<LoginPayload>(payload, ref request);

    return await Execute<Account>(request, false);
}

//204: success, anything else failure
internal async Task<Boolean> LogOut ()
{
    return await Execute<Boolean>(NewRequest(HttpMethod.Delete, "login"), true);
}

internal async Task<HttpResponseMessage> GetRawResponse ()
{
    return await Execute<HttpResponseMessage>(NewRequest(HttpMethod.Get, "raw/something"), true);
}

internal async Task<Int32> GetMeStatusCode ()
{
    return await Execute<Int32>(NewRequest(HttpMethod.Get, "some/intstatus"), true);
}

private async Task<RESULT> Execute<RESULT>(HttpRequestMessage request, bool authenticate)
{
    if (authenticate)
        AuthenticateRequest(ref request); //add auth token to request

    var tcs = new TaskCompletionSource<RESULT>();
    var response = await client.SendAsync(request);     

    //TODO: If the RESULT is just HTTPResponseMessage, the rest is unnecessary        

    if (response.IsSuccessStatusCode)
    {
        try
        {
            //TryParse needs to handle Boolean differently than other types
            RESULT result = await TryParse<RESULT>(response);
            tcs.SetResult(result);
        }
        catch (Exception e)
        {
            tcs.SetException(e);
        }

    }
    else
    {
        try
        {
            APIError error = await TryParse<APIError>(response);
            tcs.SetException(new APIException(error));
        }
        catch (Exception e)
        {
            tcs.SetException(new APIException("Unknown error"));
        }
    }

    return tcs.Task.Result;
}

Dies ist die APIError JSON-Struktur (es ist der status-code + ein benutzerdefinierter Fehler-code).

{
  "status": 404,
  "code":216,
  "msg":"User not found"
}

Ich würde lieber bleiben mit System.Net, aber das ist hauptsächlich, weil ich die nicht wechseln wollen, alle meine code über. Wenn das, was ich möchte, ist es einfacher, auf andere Weise getan, dann ist es offensichtlich lohnt sich die zusätzliche Arbeit.

Dank.

Meine Frage: Wie mache ich das? ich würde sagen, dass ein Code Überprüfen ist für code, den Sie erwägen, komplett not-code, den Sie nicht wissen, wie Sie zu vervollständigen.
Versuchen Sie suchen in der [JsonProperty("myPropertyName")], es könnte Ihnen helfen.
Also, meinst du, dass Sie bereits getan haben, die ganze UWP-Projekt getestet und es funktioniert gut, aber möchte wissen, ob dieser code ist den oben genannten Anforderungen ,und wenn Sie jemand wissen, der bessere Weg zur Umsetzung dieser Anforderungen?
Ich habe es teilweise funktioniert: Login funktioniert, weil es gibt ein Objekt zurück, aber Logout schlägt immer fehl, weil es versucht zu analysieren, den Inhalt einer 204 (NoContent) und es ist nichts da (ich möchte dies wieder true/false). Also ich brauche Hilfe bei der Rückkehr Int32 oder HttpResponseMessage je nach Typ. Ich könnte immer 3 verschiedene execute Methoden, und nennen Sie Sie entsprechend an, wenn ich muss, aber wie es scheint, fehlt mir ein kleines bisschen hier. Ein Stoß in die richtige Richtung.
Entsprechend Ihrer Idee, so scheint es code wie if (RESULT IS HttpResponseMessage)if(RESULT IS Boolen)if(!(RESULT is ValueType)) ist der einzige Weg für Ihre Anforderungen. Aber ich empfehle Sie nicht zu benutzen, die obigen code. Andere Funktionen haben separate execute-Methode, wie Sie denken ist der bessere Weg. Der code sieht aus wie ein wenig viel bedeutet nicht ein schlechtes design, ekelhaft, wie der code oben, setzen Sie die execute-Logik alles in einem, erhöhen die Kupplung. Zum Beispiel, wenn Sie nur wollen, ändern Sie die Logik der Abmeldung, sollten Sie aktualisieren nur die execute-Methode, versehentlich berührt die Login-Funktion.

InformationsquelleAutor copolii | 2016-03-23

c#system.net win-universal-app

Hier ist ein Beispiel, wie ich 've getan es mit MVC-API-2-als backend. Mein backend gibt ein json-Ergebnis, wenn die Anmeldeinformationen korrekt sind. UserCredentials Klasse ist genau das gleiche Modell wie das json-Ergebnis.Verwenden Sie System.Net.Http.Formatting Hexe finden Sie in der Microsoft.AspNet.WebApi.Client NugetPackage

public static async Task<UserCredentials> Login(string username, string password)
{
    string baseAddress = "127.0.0.1/";
    HttpClient client = new HttpClient();

    var authorizationHeader = Convert.ToBase64String(Encoding.UTF8.GetBytes("xyz:secretKey"));
    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authorizationHeader);



    var form = new Dictionary<string, string>
    {
        { "grant_type", "password" },
        { "username", username },
        { "password", password },
    };

    var Response = await client.PostAsync(baseAddress + "oauth/token", new FormUrlEncodedContent(form));
    if (Response.StatusCode == HttpStatusCode.OK)
    {
        return await Response.Content.ReadAsAsync<UserCredentials>(new[] { new JsonMediaTypeFormatter() });
    }
    else
    {
        return null;
    }
}

braucht man auch Newtonsoft.Json Paket.

public class UserCredentials
    {
    [JsonProperty("access_token")]
    public string AccessToken { get; set; }

    [JsonProperty("token_type")]
    public string TokenType { get; set; }

    [JsonProperty("expires_in")]
    public int ExpiresIn { get; set; }

    //more properties...
    }

Die wortreich-Methoden sind genau das, was ich vermeiden möchte. Auch, gibt es einen Grund, warum man das instanziieren einer neuen HttpClient in jeder Methode oder hast du gehört, dass nur der Vollständigkeit halber? Ich habe deklariert eine Instanz der HttpClient in meinem ServerAPI Klasse und planen Sie eine route alle Anfragen durch, die. Danke.
Richtig, es war nur der Vollständigkeit halber. Ich war auch zwischen wortreich oder somethink mehr universell, sondern ich wähle, um zu behandeln jeden api-Aufruf in verschiedenen Methode, weil es einfacher für mich zu handhaben, was ich zu tun habe. Ist auch einfacher für meine Teamkollegen, es zu verstehen und änderungen vornehmen.

InformationsquelleAutor Stamos

So, erste Adresse der müssen Sie Newtonsoft.Json Kommentare, ich habe wirklich nicht das Bedürfnis noch. Ich habe festgestellt, das errichtet in der Unterstützung für die Arbeit gut so weit (mit der APIError Json in meiner ursprünglichen Frage:

[DataContract]
internal class APIError
{
    [DataMember (Name = "status")]
    public int StatusCode { get; set; }
    [DataMember (Name = "code")]
    public int ErrorCode { get; set; }
}

Habe ich auch definiert JsonHelper Klasse zu (de)serialisieren:

public class JsonHelper
{
    public static T fromJson<T> (string json)
    {
        var bytes = Encoding.Unicode.GetBytes (json);

        using (MemoryStream mst = new MemoryStream(bytes))
        {
            var serializer = new DataContractJsonSerializer (typeof (T));
            return (T)serializer.ReadObject (mst);
        }
    }

    public static string toJson (object instance)
    {
        using (MemoryStream mst = new MemoryStream())
        {
            var serializer = new DataContractJsonSerializer (instance.GetType());
            serializer.WriteObject (mst, instance);
            mst.Position = 0;

            using (StreamReader r = new StreamReader(mst))
            {
                return r.ReadToEnd();
            }
        }
    }
}

Den oben genannten bits hatte ich auch schon arbeiten. Als für eine einzelne Methode, die behandeln würde, jede Anfrage Ausführung basierend auf der Art der Ergebnisse erwartet, während es macht es leichter zu ändern wie ich die Dinge Handhabe (wie Fehler, etc), es erhöht auch die Komplexität und damit die Lesbarkeit meines Codes. Ich landete separaten Methoden (alle Varianten der Execute Methode in der ursprünglichen Frage:

//execute and return response.StatusCode
private static async Task<HttpStatusCode> ExecuteForStatusCode (HttpRequestMessage request, bool authenticate = true)
//execute and return response without processing
private static async Task<HttpResponseMessage> ExecuteForRawResponse(HttpRequestMessage request, bool authenticate = true)
//execute and return response.IsSuccessStatusCode
private static async Task<Boolean> ExecuteForBoolean (HttpRequestMessage request, bool authenticate = true)
//execute and extract JSON payload from response content and convert to RESULT 
private static async Task<RESULT> Execute<RESULT>(HttpRequestMessage request, bool authenticate = true)

Ich kann bewegen, die unbefugte Antworten (was mein Aktueller code ist nicht die Handhabung, im Moment jedenfalls) in einer neuen Methode CheckResponse wird (zum Beispiel) melden Sie den Benutzer aus, wenn ein 401 empfangen wird.

InformationsquelleAutor copolii

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.