Flynk.Net.Services.Transmit.Grpc 1.3.1

Flynk.Net.Services.Transmit.Grpc

A high-performance gRPC-based messaging library for .NET that provides typed RPC communication with routing, serialization, and bidirectional streaming.

Packages

Package	Description	NuGet
Flynk.Net.Services.Transmit.Grpc.Common	Shared infrastructure (proto types, RpcHandlerRegistry, utilities). Auto-included with Client/Server.
Flynk.Net.Services.Transmit.Grpc.Client	Lightweight client library. No ASP.NET Core dependencies.
Flynk.Net.Services.Transmit.Grpc.Server	Server hosting library with ASP.NET Core integration.

Package Dependencies

    Common (1.3.0)
      ↑         ↑
      |         |
  Client     Server
  (1.3.0)    (1.3.0)
      ↖       ↗
        Test

Both Client and Server depend on Common. All three packages should use matching versions.

Features

• Typed request/response handling with automatic JSON serialization
• Route-based message handlers
• Bidirectional streaming communication
• Built-in reconnection with configurable settings
• Service discovery via Info endpoint
• Port validation and conflict detection
• Security controls for client-to-client communication

Quick Start

Server Setup

dotnet new web -n MyServer
cd MyServer
dotnet add package Flynk.Net.Services.Transmit.Grpc.Server

Program.cs:

using Flynk.Net.Services.Transmit.Grpc.Server;
using Flynk.Net.Services.Transmit.Grpc.Server.Extensions;
using Flynk.Net.Services.Transmit.Grpc.Client;

var builder = WebApplication.CreateBuilder(args);
builder.AddTransmissionService(grpcPort: 5001);

var app = builder.Build();
app.MapTransmissionService();

// Handle requests sent to server
RpcHandlerRegistry.RegisterServerHandler(async (request) =>
{
    Console.WriteLine($"Received: {request.MessageType}");
    return new TransmissionResponse
    {
        Id = Guid.NewGuid().ToString(),
        CorrelationId = request.Id,
        Success = true,
        StatusCode = 200,
        Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
    };
}, serverId: "server");

app.Run();

Client Setup

dotnet new console -n MyClient
cd MyClient
dotnet add package Flynk.Net.Services.Transmit.Grpc.Client

Program.cs:

using Flynk.Net.Services.Transmit.Grpc.Client;
using Microsoft.Extensions.Logging;

var loggerFactory = LoggerFactory.Create(b => b.AddConsole());
var logger = loggerFactory.CreateLogger<RpcClient>();

using var client = new RpcClient(address: "http://localhost:5001", id: "my-client", logger: logger);

// Send request to server
var response = await client.RequestAsync<PingRequest, PingResponse>(
    route: "ping",
    request: new PingRequest { Message = "Hello!" },
    timeout: TimeSpan.FromSeconds(10)  // Optional timeout
);

Console.WriteLine($"Success: {response.IsOK}");

public record PingRequest(string Message);
public record PingResponse(string Reply);

Security

By default, clients can only communicate with the server. To enable client-to-client messaging (if your application requires it):

// On server - enable peer-to-peer messaging
RpcHandlerRegistry.EnableClientToClientCommunication();

Documentation

• Quick Start Guide
• Implementation Guide
• API Reference

Architecture

┌─────────────────┐         ┌─────────────────┐
│   RpcClient     │────────▶│TransmissionClient│
│  (High-level)   │         │   (Low-level)    │
└─────────────────┘         └─────────────────┘
        │                            │
        ▼                            ▼
┌─────────────────┐         ┌─────────────────┐
│ Route Handlers  │         │  gRPC Service   │
└─────────────────┘         └─────────────────┘

Key Classes

Client Package

• RpcClient - High-level client with typed routing
• TransmissionClient - Low-level gRPC client
• RpcClientSettings - Connection configuration
• RpcHandlerRegistry - Handler registration
• Response<T> - Response wrapper

Server Package

• TransmissionServiceImpl - gRPC service implementation
• WebApplicationBuilderExtensions - Host configuration
• ServiceCollectionExtensions - DI registration
• PortUtility - Port management utilities

Route Naming Convention

Use hierarchical dot notation:

"user.create"
"user.update"
"order.process"
"payment.authorize"

Response Handling

// In handlers
return Response<T>.OK(payload);
return Response<T>.OK(payload, "Success message");
return Response<T>.FAILED("Error description");

// Checking responses
if (response.IsOK)
{
    var data = response.Payload;
}
else
{
    Console.WriteLine(response.Message);
}

Configuration Options

Client Settings

var settings = new RpcClientSettings
{
    EnableReconnection = true,
    ReconnectionDelaySeconds = 5,
    MaxReconnectionAttempts = 10  // -1 for unlimited
};

Server Options

builder.AddTransmissionService(options =>
{
    options.HttpPort = 5000;        // REST API
    options.GrpcPort = 5001;        // gRPC
    options.Host = "0.0.0.0";       // All interfaces
    options.ValidatePorts = true;
});

Troubleshooting

Port Conflicts

using Flynk.Net.Services.Transmit.Grpc.Utilities;

if (!PortUtility.IsPortAvailable(5001))
{
    Console.WriteLine(PortUtility.CreatePortConflictMessage(5001));
}

Handler Not Found

• Ensure RegisterServerHandler() is called before app.Run()
• Verify route names match exactly (case-sensitive)
• For client-to-client: ensure EnableClientToClientCommunication() is called

Connection Issues

Enable debug logging:

builder.Logging.SetMinimumLevel(LogLevel.Debug);

License

This software is licensed under the Flynk Freeware License.

Support

For issues or questions, please contact the development team or create an issue in the repository.