Is it possible to run services on both stream endpoints?

[lostmsu]

E.g. I want host 1 to get an instance of IHost2 and host 2 to get an instance of IHost1 over a single duplex stream. It is possible?

On host 1 JsonRpc.Attach<IHost2> does not have an overload where I could pass an instance target that implements IHost1.

[JRuggero]

On host1:

            _serverMethods = new Host1();
            _jsonRpc = new JsonRpc(new WebSocketMessageHandler(_webSocketStream, new MessagePackFormatter()), _serverMethods)
            {
                CancelLocallyInvokedMethodsWhenConnectionIsClosed = true
            };

            ClientMethods = _jsonRpc.Attach<IHost2>();

            _jsonRpc.StartListening();
            await _jsonRpc.Completion;

On host2:

            _serverMethods = new Host2();
            _jsonRpc = new JsonRpc(new `WebSocketMessageHandler(_webSocketStream, new MessagePackFormatter()), _serverMethods)
            {
                CancelLocallyInvokedMethodsWhenConnectionIsClosed = true
            };

            ClientMethods = _jsonRpc.Attach<IHost1>();

            _jsonRpc.StartListening();
            await _jsonRpc.Completion;

[lostmsu]

I don't really have a WebSocketStream should I construct one?

[JRuggero]

I used WebSocketStream just as example. You can use any stream as transport.

[AArnott]

I liked this answer better, because you're creating Host2 and a proxy to IHost1. This makes sense because each party is one thing and calls on the other thing.

[lostmsu]

I tried this, but the methods don't get called, and in the trace I get

JsonRpc Warning: 5 : No target methods are registered that match "Do1".
JsonRpc Warning: 5 : No target methods are registered that match "Do2".

using System.IO.Pipes;

using StreamJsonRpc;

class Duplex {
    public async Task RunAsync() {
        var server = new NamedPipeServerStream("JsonRpcDuplex", PipeDirection.InOut, maxNumberOfServerInstances: 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
        var client = new NamedPipeClientStream(".", "JsonRpcDuplex", PipeDirection.InOut, PipeOptions.Asynchronous);
        await Task.WhenAll(server.WaitForConnectionAsync(), client.ConnectAsync()).ConfigureAwait(false);
        var s1 = this.Server1(server, client);
        var s2 = this.Server2(client, server);
        s1.Do2();
        s2.Do1();
    }
    IHost2 Server1(Stream send, Stream recv) {
        var host = new Host1();
        var rpc = new JsonRpc(send, recv) {
            CancelLocallyInvokedMethodsWhenConnectionIsClosed = true
        };
        rpc.AddLocalRpcTarget<IHost1>(host, null);

        var service2 = rpc.Attach<IHost2>();

        rpc.StartListening();
        return service2;
    }

    IHost1 Server2(Stream send, Stream recv) {
        var host = new Host2();
        var rpc = new JsonRpc(send, recv) {
            CancelLocallyInvokedMethodsWhenConnectionIsClosed = true
        };
        rpc.AddLocalRpcTarget<IHost2>(host, null);

        var service1 = rpc.Attach<IHost1>();

        rpc.StartListening();
        return service1;
    }

    interface IHost1 {
        void Do1();
    }

    interface IHost2 {
        void Do2();
    }

    public class Host1: IHost1 {
        public void Do1() => Debug.WriteLine("Do1");
    }

    public class Host2: IHost2 {
        public void Do2() => Debug.WriteLine("Do2");
    }
}

P.S. I also tried to pass host directly to the JsonRpc constructor instead of explicitly calling AddLocalRpcTarget.

P.P.S. I have a word to say about a failure to call a method to only raise a warning...

P.P.P.S. It throws an exception instead of just printing a warning if I change IHost* methods to be async.

[JRuggero]

• Remote Methods must return Tasks.
• service1 must Attach<IHost1> and service2 must Attach<IHost2>.

You can find your code fixed (and working) at: https://dotnetfiddle.net/GhOUsP

[AArnott]

@JRuggero, your sample on dotnetfiddle does run, but it doesn't make sense to me because you're creating Host1 and the IHost1 proxy in the some method. That suggests to me that JsonRpc is calling itself, loopback style.

[JRuggero]

Thank you @AArnott.
I agree. Just tried to make the Victor's code work with minimum changes.

[AArnott]

The pipes were indeed cross-wired, so that each party talked to themself. Here is the corrected version: https://dotnetfiddle.net/MfT0VV

The trick is that named pipes are already full duplex, so you only give one of them to each party -- not both!

[JRuggero]

Thank you @AArnott.
Mi fiddle was just bad!
It's fixed now. (I hope)

[lostmsu]

@AArnott the constructor overloads caused this confusion imho. Initially I wanted to supply the target right in the constructor, but there's no overload that takes only 1 Stream and target. So my initial code (before I made AddLocalRpcTarget explicit) got morphed into the above.

My understanding now is that with constructor overloads I would have just passed the same end of the pipe twice?

[AArnott]

Yes, that's correct.