YetAnotherHttpHandler

For local Inter-Process Communication (IPC) via gRPC, you can use Unix Domain Sockets instead of TCP.

Configuration:

1. Set the UnixDomainSocketPath property to the path of the socket.
2. Set Http2Only = true (required for UDS).
3. When using grpc-dotnet, pass an http://localhost URI to GrpcChannel.ForAddress. The handler will internally redirect requests to the UDS path.

Important Notes:

• HTTPS is not supported over UDS. All HTTPS-related configuration properties are ignored.
• If using Kestrel on the server side, you must set KestrelServerOptions.AllowAlternateSchemes = true.

using var handler = new YetAnotherHttpHandler() { Http2Only = true, UnixDomainSocketPath = "/tmp/example.sock" };
using var channel = GrpcChannel.ForAddress("http://localhost", new GrpcChannelOptions() { HttpHandler = handler });

gRPC clients are concrete types generated from .proto files. To use them, you must first create a GrpcChannel using GrpcChannel.ForAddress, which represents a long-lived connection to the service. You then pass this channel into the constructor of your generated client class.

You can configure the channel using GrpcChannelOptions to specify settings like the HttpClient, maximum message sizes, and logging.

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greet.GreeterClient(channel);

If you encounter System.DllNotFoundException: Unable to load DLL 'Cysharp.Net.Http.YetAnotherHttpHandler.Native', it is likely because the Visual C++ Redistributable Package (vcruntime140.dll) is missing.

Solution: Download and install the latest supported VC++ Redistributable from the Microsoft website.

In a client streaming call, the client sends a stream of messages to the server and waits for a single response.

Workflow:

1. Initiate the call.
2. Use RequestStream.WriteAsync to send multiple messages.
3. Call RequestStream.CompleteAsync() to notify the server that the client has finished sending.
4. Await the call object itself to receive the final response message.

var client = new Counter.CounterClient(channel);
using var call = client.AccumulateCount();

for (var i = 0; i < 3; i++)
{
    await call.RequestStream.WriteAsync(new CounterRequest { Count = 1 });
}
await call.RequestStream.CompleteAsync();

var response = await call;
Console.WriteLine($"Count: {response.Count}");

A unary call is a simple request-response pattern. For every unary method defined in a .proto file, the generated client provides two methods:

1. MethodNameAsync: An asynchronous method that can be awaited (recommended).
2. MethodName: A blocking method that blocks the thread until the response is received (do not use in asynchronous code).

Example of an asynchronous unary call:

var client = new Greet.GreeterClient(channel);
var response = await client.SayHelloAsync(new HelloRequest { Name = "World" });

Console.WriteLine("Greeting: " + response.Message);

In a server streaming call, the client sends one request and the server responds with a stream of messages. You can consume the stream using ResponseStream.MoveNext() in a loop, or more idiomatically using await foreach with the ReadAllAsync() extension method (available in C# 8+).

Note: Ensure you wrap the call in a using block to properly dispose of the call object.

var client = new Greet.GreeterClient(channel);
using var call = client.SayHellos(new HelloRequest { Name = "World" });

await foreach (var response in call.ResponseStream.ReadAllAsync())
{
    Console.WriteLine("Greeting: " + response.Message);
}

YetAnotherHttpHandler is a drop-in replacement for HttpClient handlers. To enable HTTP/2 support, instantiate YetAnotherHttpHandler and pass it to the HttpClient constructor.

YetAnotherHttpHandler and HttpClient can be shared across multiple threads or requests. However, because the handler does not support connection control by the number of streams, you must create separate handler instances if you need to explicitly manage different connections.

using Cysharp.Net.Http;

using var handler = new YetAnotherHttpHandler();
var httpClient = new HttpClient(handler);

var result = await httpClient.GetStringAsync("https://www.example.com");

To bypass HTTPS certificate validation (not recommended for production), set the SkipCertificateVerification property to true.

using var handler = new YetAnotherHttpHandler() { SkipCertificateVerification = true };

By default, YetAnotherHttpHandler uses Mozilla's root certificates (derived from webpki). To use self-signed certificates or organization-issued certificates, provide the root certificates in PEM format via the RootCertificates property.

var rootCerts = @"
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
";
using var handler = new YetAnotherHttpHandler() { RootCertificates = rootCerts };