Por que usar o HttpClient para conexão síncrona

Estou construindo uma biblioteca de classes para interagir com uma API. Preciso chamar a API e processar a resposta XML. Posso ver os benefícios de usar HttpClientpara conectividade assíncrona, mas o que estou fazendo é puramente síncrono, portanto, não vejo nenhum benefício significativo sobre o uso HttpWebRequest.

Se alguém puder lançar alguma luz, eu apreciaria muito. Eu não sou do tipo que usa novas tecnologias por causa disso.

mas o que estou fazendo é puramente síncrono

Você pode usar HttpClientpara solicitações síncronas muito bem:

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

No que diz respeito ao motivo pelo qual você deve usar o HttpClientexcesso WebRequest, bem, HttpClienté o novo garoto do setor e pode conter melhorias em relação ao cliente antigo.

Eu reiterava a resposta de Donny V. e a de Josh

"O único motivo pelo qual eu não usaria a versão assíncrona é se eu estava tentando oferecer suporte a uma versão mais antiga do .NET que ainda não possui suporte assíncrono."

(e voto positivo, se eu tivesse reputação.)

Não me lembro da última vez, fiquei grato pelo fato de o HttpWebRequest ter lançado exceções para códigos de status> = 400. Para contornar esses problemas, você precisa capturar as exceções imediatamente e mapeá-las para alguns mecanismos de resposta que não sejam de exceção no seu código ... chato, tedioso e propenso a erros em si. Seja comunicando-se com um banco de dados ou implementando um proxy da Web sob medida, é quase sempre desejável que o driver Http diga ao código do aplicativo o que foi retornado e deixe que você decida como se comportar.

Portanto, o HttpClient é preferível.

Se você estiver criando uma biblioteca de classes, talvez os usuários da sua biblioteca desejem usá-la de forma assíncrona. Eu acho que essa é a maior razão aqui.

Você também não sabe como sua biblioteca será usada. Talvez os usuários processem muitas e muitas solicitações, e fazê-lo de forma assíncrona ajudará a executar com mais rapidez e eficiência.

Se você puder fazer isso de forma simples, tente não sobrecarregar os usuários da sua biblioteca, tentando tornar o fluxo assíncrono quando puder cuidar dele.

O único motivo pelo qual eu não usaria a versão assíncrona é se eu estava tentando oferecer suporte a uma versão mais antiga do .NET que ainda não possui suporte assíncrono.

No meu caso, a resposta aceita não funcionou. Eu estava chamando a API de um aplicativo MVC que não tinha ações assíncronas.

Foi assim que consegui fazê-lo funcionar:

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

Então eu chamei assim:

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

Então

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

se você usar essa classe, passe seu método assíncrono como parâmetro, poderá chamar os métodos assíncronos de métodos sincronizados de maneira segura.

é explicado aqui: https://cpratt.co/async-tips-tricks/

Todas as respostas parecem focar no uso HttpClientsíncrono, em vez de dar uma resposta real à pergunta.

HttpClienté mais do que um simples manipulador de solicitação / resposta, para que ele possa lidar com algumas peculiaridades de diferentes redes. Ou seja, no meu caso, trabalhando com o proxy NTLM, que requer negociação, enviando várias solicitações / respostas com tokens e credenciais entre o cliente e o servidor proxy para autenticação. HttpClient(using HttpClientHandler) parece ter um mecanismo interno que lida com o retorno de recursos além do proxy com uma chamada de método.