public static class EchoServerMethodIds
{
    public static readonly DefaultMethodId DirectEcho = new(1, "DirectEcho");
    public static readonly DefaultMethodId ReverseEcho = new(2, "ReverseEcho");
}

public class EchoResponse
{
    public DateTime ReceiveDate { get; set; }
    public string Message { get; set; }
}

public interface IEcho
{
    Task<EchoResponse> DirectAsync(string message, CancellationToken ct);
    Task<EchoResponse> ReverseAsync(string message, CancellationToken ct);
}

public class EchoLogic : IEcho
{
    async Task<EchoResponse> IEcho.DirectAsync(string message, CancellationToken ct)
    {
        await Task.Delay(100, ct);

        return new EchoResponse
        {
            ReceiveDate = DateTime.UtcNow,
            Message = message
        };
    }

    async Task<EchoResponse> IEcho.ReverseAsync(string message, CancellationToken ct)
    {
        await Task.Delay(100, ct);

        char[] msg = message.ToCharArray();
        msg.Reverse();

        return new EchoResponse
        {
            ReceiveDate = DateTime.UtcNow,
            Message = new string(msg)
        };
    }
}

public EchoStub : IStub
{
    public EchoStub(IEcho service)
    {
        mService = service;
    }

    bool IStub.CanHandleMethod(IMethodId method)
    {
        // Remember to cast the IMethodId to the correct type if you decide to 
        // use your own IMethodId implementation
        DefaultMethodId dmi = Unsafe.As<DefaultMethodId>(method);

        // DefaultMethodId overrides all operators
        // This eases CanHandleMethod implementations by distributing methods
        // in consecutive ranges and just checking for the range limits
        return dmi >= EchoServerMethodIds.DirectEcho
            && dmi <= EchoServerMethodIds.ReverseEcho;
    }

    IEnumerable<IMethodId> IStub.GetHandledMethods()
    {
        // If more than one stub declares that can handle the same method,
        // miloRpc will cause your application to HALT to prevent a logic error
        // that could potentially lead to data loss
        return new IMethodId[]
        {
            EchoServerMethodIds.DirectEcho,
            EchoServerMethodIds.ReverseEcho
        };
    }

    Task<RpcNetworkMessages> IStub.RunMethodCallAsync(
        IMethodId methodId,
        BinaryReader reader,
        IConnectionContext connectionContext,
        Func<CancellationToken> beginMethodRunCallback)
    {
        DefaultMethodId dmi = Unsafe.As<DefaultMethodId>(methodId);

        if (dmi == EchoServerMethodIds.DirectEcho)
            return await RunDirectEchoAsync(reader, beginMethodRunCallback);

        if (dmi == EchoServerMethodIds.ReverseEcho)
            return await RunReverseEchoAsync(reader, beginMethodRunCallback);

        // Can't happen because the framework will prevent calling the IStub
        // with a method that the IStub does not declare
        throw new NotSupportedException("Unknown method");
    }

    // You don't need to wrap these methods in a try/catch block
    // If an exception happens in your code, the framework will pick it up
    // and serialize it back to the client, so you can safely propagate
    // exceptions and stack traces
    Task<RpcNetworkMessages> RunDirectEchoAsync(
        BinaryReader reader,
        Func<CancellationToken> beginMethodRunCallback)
    {
        // You can only use generic NetworkMessages when using the
        // miloRpc.Serialization package.
        // These messages handle serialization and deserialization in a
        // transparent way - as long as the adequate ISerializer implementations
        // are in place (more on this following the example).
        // Otherwise you need to implement your own messages derived from the
        // INetworkMessage interface
        NetworkMessage<string> request = new();
        request.Deserialize(reader);

        // The callback must be called once the request is deserialized
        // This allows the framework to track read and execution times, and the
        // returned CancellationToken will be cancelled after the execution
        // timeout configured when starting up the miloRpc server expires
        CancellationToken ct = beginMethodRunCallback();

        EchoResponse result = await mService.DirectAsync(request.Val1, ct);

        // If you don't have serializers for the model you want to send
        // accross the network, you can use NetworkMessage with primitive types
        // and assign the members of your complex objects one by one
        NetworkMessage<DateTime, string> response = new();
        response.Val1 = result.ReceiveDate;
        response.Val2 = result.Message;

        return new RpcNetworkMessages(request, response);
    }

    Task<RpcNetworkMessages> RunReverseEchoAsync(
        BinaryReader reader,
        Func<CancellationToken> beginMethodRunCallback)
    {
        NetworkMessage<string> request = new();
        request.Deserialize(reader);

        CancellationToken ct = beginMethodRunCallback();

        EchoResponse result = await mService.ReverseAsync(request.Val1, ct);

        // For this to work you need to code and register a ISerializer<EchoResponse>
        NetworkMessage<EchoResponse> response = new();
        response.Val1 = result;

        return new RpcNetworkMessages(request, response);
    }

    readonly IEcho mService;
}

// All ISerializer implementations should be thread safe
public class EchoResponseSerializer : ISerializer<EchoResponse>
{
    public EchoResponseSerializer()
    {
        // Bear in mind that you can only access already registered serializers
        //
        // When having a dependency tree, first register the serializers for
        // the leaf objects, then for those that depend on them
        mDateTimeSerializer = Serializers.Get<DateTime>();
        mStringSerializer = Serializers.Get<string>();
    }

    EchoResponse ISerializer<EchoResponse>.Deserialize(BinaryReader reader)
    {
        // The fields must be read in the same order they were written
        return new EchoResponse
        {
            ReceiveDate = mDateTimeSerializer.Deserialize(reader),
            Message = mStringSerializer.Deserialize(reader)
        };
    }

    void ISerializer<EchoResponse>.Serialize(BinaryWriter writer, EchoResponse t)
    {
        // The fields must be read in the same order they were written
        mDateTimeSerializer.Serialize(writer, t.ReceiveDate);
        mStringSerializer.Serialize(writer, t.Message);
    }

    readonly ISerializer<DateTime> mDateTimeSerializer;
    readonly ISerializer<string> mStringSerializer;
}

public static async Task Main(string[] args)
{
    // Some code...
    Serializers.RegisterInstance(new EchoResponseSerializer());
    // Some more code...
}

public static async Task Main(string[] args)
{
    // Some code...
    Serializers.RegisterInstance(new EchoResponseSerializer());
    // Some more code...

    StubCollection stubs = new(new EchoStub(new EchoLogic()));

    IPEndPoint serverEndPoint = IPEndPoint.Parse("0.0.0.0:9999");

    // To use the TcpServer you need package miloRpc.Channels.Tcp
    IServer<IPEndPoint> server = new TcpServer(serverEndPoint, stubs);

    CancellationTokenSource cts = new();
    Console.CancelKeyPress  = (_, e) =>
    {
        Console.WriteLine("Cancellation requested!");
        cts.Cancel();
        e.Cancel = true;
    }

    // The task will finish when the token gets cancelled
    Console.WriteLine("Press CTRL   C to exit");
    await server.ListenAsync(cts.Token);
}

public class EchoProxy : IEcho
{
    public EchoProxy(ConnectionPool connPool)
    {
        // Each ConnectionPool instance pools connections to a single server/endpoint
        mPool = connPool;
    }

    async Task<EchoResponse> IEcho.DirectAsync(string message, CancellationToken ct)
    {
        ConnectionToServer conn = await mPool.RentConnectionAsync(TimeSpan.Zero, ct);
        try
        {
            NetworkMessage<string> request = new();
            request.Val1 = message;

            NetworkMessage<DateTime, string> response = new();

            RpcNetworkMessages messages = new(request, response);

            // By the time ProcessMethodCallAsync ends, 'response' will be
            // deserialized with what the server sent
            await conn.ProcessMethodCallAsync(
                EchoServerMethodIds.DirectEcho,
                messages,
                ct);

            return new EchoResponse
            {
                ReceiveDate = response.Val1,
                Message = response.Val2
            };
        }
        finally
        {
            // Remember to return your connection to the pool!
            mPool.ReturnConnection(conn);
        }
    }

    async Task<EchoResponse> IEcho.ReverseAsync(string message, CancellationToken ct)
    {
        ConnectionToServer conn = await mPool.RentConnectionAsync(TimeSpan.Zero, ct);
        try
        {
            NetworkMessage<string> request = new();
            request.Val1 = message;

            NetworkMessage<EchoResponse> response = new();

            RpcNetworkMessages messages = new(request, response);

            await conn.ProcessMethodCallAsync(
                EchoServerMethodIds.ReverseEcho,
                messages,
                ct);

            return response.Val1;
        }
        finally
        {
            mPool.ReturnConnection(conn);
        }
    }

    readonly ConnectionPool mPool;
}

public static async Task Main(string[] args)
{
    IPEndPoint serverEndPoint = IPEndPoint.Parse("192.168.1.10:9999");
    IConnectToServer connectToServer = new ConnectToTcpServer(serverEndPoint);
    ConnectionPool pool = new ConnectionPool(
        connectToServer,
        minimumPooledConnections: 2);

    // If you want to eat up the time of creating new connections at the beginning...
    await pool.WarmUpPool();

    CancellationTokenSource cts = new();
    cts.CancelAfter(TimeSpan.FromSeconds(2));

    IEcho echo = new EchoProxy(pool);

    // Thanks to the ConnectionPool we can make calls in parallel
    Task<EchoResponse> directResponseTask =
        echo.DirectAsync("hello world!", cts.Token);

    Task<EchoResponse> reverseResponseTask =
        echo.ReverseAsync("hello world!", cts.Token);

    await Task.WhenAll(directResponseTask, reverseResponseTask);

    Console.WriteLine(directResponseTask.Result.Message);  // hello world!
    Console.WriteLine(reverseResponseTask.Result.Message); // !dlrow olleh
}

var connSettings = new ConnectionSettings
{
    CompressionSettings = new()
    {
        Status = SharedCapabilityEnablement.Optional,
        ArrayPool = ArrayPool<byte>.Shared
    },
    SslSettings = new()
    {
        Status = SharedCapabilityEnablement.Mandatory,
        CertificatePath = "/path/to/my/file.pfx",
        CertificatePassword = "1234",
        ApplicationProtocols = new List<SslApplicationProtocol>()
        {
            new SslApplicationProtocol("echo-server-protocol")
        }
    },
    BufferingSettings = new()
    {
        Status = PrivateCapabilityEnablement.Enabled,
        BufferSize = 4096
    }
};

INegotiateRpcProtocol negotiateRpcProtocol =
    new DefaultServerProtocolNegotiation(connSettings)

IServer<IPEndPoint> tcpServer =
    new TcpServer(bindTo, stubCollection, negotiateRpcProtocol);

ILoggerFactory loggerFactory = MyMagicMethod();
RpcLoggerFactory.RegisterLoggerFactory(loggerFactory);