Can HttpClient (C#) be used with HTTP/2?

Yes, HttpClient in C# can be used with HTTP/2. Starting with .NET Core 2.1, HttpClient supports HTTP/2. However, it's important to note that not all servers support HTTP/2, and the server needs to be configured to support HTTP/2 for the client to use it.

You can specify the HTTP version in HttpClient by setting the Version property of HttpRequestMessage to HttpVersion.Version20. Here's an example of how to send an HTTP/2 request using HttpClient:

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // Create an instance of HttpClient
        using (var client = new HttpClient())
        {
            // Create an HttpRequestMessage
            var request = new HttpRequestMessage()
            {
                RequestUri = new Uri("https://example.com"),
                Method = HttpMethod.Get,
                Version = new Version(2, 0) // Set HTTP/2 here
            };

            try
            {
                // Send the request
                HttpResponseMessage response = await client.SendAsync(request);

                // Ensure we got a successful response
                if (!response.IsSuccessStatusCode)
                {
                    Console.WriteLine($"Error: {response.StatusCode}");
                }
                else
                {
                    // Read the response content
                    string content = await response.Content.ReadAsStringAsync();
                    Console.WriteLine(content);
                }
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine($"Request exception: {e.Message}");
            }
        }
    }
}

In .NET Core 2.1 and later, HttpClient will attempt to negotiate HTTP/2 with the server by default. If the server does not support HTTP/2, it will fall back to HTTP/1.1. However, when you explicitly set the HTTP version to 2.0, as shown in the example above, HttpClient will not fall back to HTTP/1.1, and you may receive an error if the server does not support HTTP/2.

When deploying to environments that use older versions of the .NET Framework or where HTTP/2 support is not available, you may need to ensure that you are using a compatible runtime and that the server supports HTTP/2.

To enable HTTP/2 support in Kestrel (the default web server for ASP.NET Core applications), you can configure the server to use HTTP/2 in the appsettings.json or Program.cs file:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
            webBuilder.ConfigureKestrel(options =>
            {
                options.ListenAnyIP(5001, listenOptions =>
                {
                    listenOptions.Protocols = HttpProtocols.Http1AndHttp2;
                    listenOptions.UseHttps();
                });
            });
        });

This configuration sets Kestrel to listen for both HTTP/1 and HTTP/2 traffic on port 5001 and requires HTTPS, which is a common requirement for HTTP/2.

Keep in mind that HTTP/2 features such as server push are not supported by HttpClient as of the current .NET versions (up to .NET 6). Additionally, not all features of HTTP/2 may be supported by HttpClient, so you should review the documentation for the version of .NET you are using to understand the full capabilities and limitations.