Warum sollten Sie HttpClient für die synchrone Verbindung verwenden?

Ich baue eine Klassenbibliothek auf, um mit einer API zu interagieren. Ich muss die API aufrufen und die XML-Antwort verarbeiten. Ich kann die Vorteile der Verwendung HttpClientfür die asynchrone Konnektivität erkennen, aber was ich tue, ist rein synchron, sodass ich keinen signifikanten Vorteil gegenüber der Verwendung sehe HttpWebRequest.

Wenn jemand Licht ins Dunkel bringen kann, würde ich es sehr schätzen. Ich bin nicht einer, der dafür neue Technologien einsetzt.

aber was ich tue ist rein synchron

Sie können HttpClientfür synchrone Anfragen ganz gut verwenden:

using (var client = new HttpClient())
{
    var response = client.GetAsync("http://google.com").Result;

    if (response.IsSuccessStatusCode)
    {
        var responseContent = response.Content; 

        // by calling .Result you are synchronously reading the result
        string responseString = responseContent.ReadAsStringAsync().Result;

        Console.WriteLine(responseString);
    }
}

Was den Grund betrifft, warum Sie HttpClientover verwenden sollten WebRequest, HttpClientist das neue Kind auf dem Block und könnte Verbesserungen gegenüber dem alten Client enthalten.

Ich würde die Antwort von Donny V. und Josh wiederholen

"Der einzige Grund, warum ich die asynchrone Version nicht verwenden würde, ist, wenn ich versuchen würde, eine ältere Version von .NET zu unterstützen, die noch keine integrierte asynchrone Unterstützung bietet."

(und positiv, wenn ich den Ruf hatte.)

Ich kann mich nicht an das letzte Mal erinnern, wenn überhaupt, war ich dankbar dafür, dass HttpWebRequest Ausnahmen für Statuscodes> = 400 ausgelöst hat. Um diese Probleme zu umgehen, müssen Sie die Ausnahmen sofort abfangen und sie einigen Nicht-Ausnahme-Antwortmechanismen zuordnen in Ihrem Code ... langweilig, langweilig und fehleranfällig an sich. Unabhängig davon, ob Sie mit einer Datenbank kommunizieren oder einen maßgeschneiderten Webproxy implementieren, ist es „fast“ immer wünschenswert, dass der HTTP-Treiber Ihrem Anwendungscode nur mitteilt, was zurückgegeben wurde, und es Ihnen überlässt, zu entscheiden, wie Sie sich verhalten.

Daher ist HttpClient vorzuziehen.

Wenn Sie eine Klassenbibliothek erstellen, möchten die Benutzer Ihrer Bibliothek Ihre Bibliothek möglicherweise asynchron verwenden. Ich denke, das ist genau dort der größte Grund.

Sie wissen auch nicht, wie Ihre Bibliothek verwendet werden soll. Vielleicht werden die Benutzer viele, viele Anfragen bearbeiten, und wenn Sie dies asynchron tun, können Sie schneller und effizienter arbeiten.

Wenn Sie dies einfach tun können, versuchen Sie, die Benutzer Ihrer Bibliothek nicht zu belasten, indem Sie versuchen, den Ablauf asynchron zu gestalten, wenn Sie sich um sie kümmern können.

Der einzige Grund, warum ich die asynchrone Version nicht verwenden würde, ist, wenn ich versuchen würde, eine ältere Version von .NET zu unterstützen, die noch keine integrierte asynchrone Unterstützung bietet.

In meinem Fall hat die akzeptierte Antwort nicht funktioniert. Ich habe die API von einer MVC-Anwendung aufgerufen, die keine asynchronen Aktionen hatte.

So habe ich es geschafft:

private static readonly TaskFactory _myTaskFactory = new TaskFactory(CancellationToken.None, TaskCreationOptions.None, TaskContinuationOptions.None, TaskScheduler.Default);
public static T RunSync<T>(Func<Task<T>> func)
    {           
        CultureInfo cultureUi = CultureInfo.CurrentUICulture;
        CultureInfo culture = CultureInfo.CurrentCulture;
        return _myTaskFactory.StartNew<Task<T>>(delegate
        {
            Thread.CurrentThread.CurrentCulture = culture;
            Thread.CurrentThread.CurrentUICulture = cultureUi;
            return func();
        }).Unwrap<T>().GetAwaiter().GetResult();
    }

Dann habe ich es so genannt:

Helper.RunSync(new Func<Task<ReturnTypeGoesHere>>(async () => await AsyncCallGoesHere(myparameter)));

public static class AsyncHelper  
{
    private static readonly TaskFactory _taskFactory = new
        TaskFactory(CancellationToken.None,
                    TaskCreationOptions.None,
                    TaskContinuationOptions.None,
                    TaskScheduler.Default);

    public static TResult RunSync<TResult>(Func<Task<TResult>> func)
        => _taskFactory
            .StartNew(func)
            .Unwrap()
            .GetAwaiter()
            .GetResult();

    public static void RunSync(Func<Task> func)
        => _taskFactory
            .StartNew(func)
            .Unwrap()
            .GetAwaiter()
            .GetResult();
}

Dann

AsyncHelper.RunSync(() => DoAsyncStuff());

Wenn Sie diese Klasse verwenden und Ihre asynchrone Methode als Parameter übergeben, können Sie die asynchronen Methoden auf sichere Weise aus den Synchronisierungsmethoden aufrufen.

Es wird hier erklärt: https://cpratt.co/async-tips-tricks/

Alle Antworten scheinen sich auf die HttpClientsynchrone Verwendung zu konzentrieren, anstatt die Frage tatsächlich zu beantworten.

HttpClientist mehr als ein einfacher Anforderungs- / Antwort-Handler, mit dem einige Besonderheiten verschiedener Netzwerke behandelt werden können. In meinem Fall nämlich mit einem NTLM-Proxy arbeiten, für den eine Verhandlung erforderlich ist, und mehrere Anfragen / Antworten mit Token und Anmeldeinformationen zwischen Client und Proxyserver zur Authentifizierung senden. HttpClient(using HttpClientHandler) scheint einen eingebauten Mechanismus zu haben, der mit einem Methodenaufruf Ressourcen jenseits des Proxys zurückgibt.