Is this an ugly/incorrect usage of subscriptions? Little backstory: I'm trying to write code that will read messages from INetworkConnection that the INetworkConnection publishes and then send those up to the NetworkController which should do some processing and then send that off to an injected IObserver&lt;IMessage&gt; (which is a single observer because there's a global listener interested in network messages).

In other words, I'm trying to read messages, transform them, and then push them off to some listener. The reason why the controller is not subscribable is because there is only meant to be one listener (which will then distribute messages as necessary).

Now, right now I haven't added the transformation, so all the network controller does is that it pipes the messages from every connection into the injected subscriber like so:

    private readonly IDisposable _networkConnectionStreamSubscription;
    private readonly IObserver&lt;INetworkMessage&gt; _networkMessageStream;

    public NetworkController(IObservable&lt;INetworkConnection&gt; networkConnectionStream,
        IObserver&lt;INetworkMessage&gt; networkMessageStream)
    {
        _networkConnectionStreamSubscription = networkConnectionStream.Subscribe(
            x =&gt; LinkWith(x),
            () =&gt; Close());
        _networkMessageStream = networkMessageStream;
    }

    /// &lt;summary&gt;
    /// Link the Controller with the given Connection, allowing the network
    /// controller to start listening for network messages.
    /// &lt;/summary&gt;
    /// &lt;param name="networkConnection"&gt;&lt;/param&gt;
    public void LinkWith(INetworkConnection networkConnection)
    {
        // Subscribe to the network message, and pipe the messages that have been parsed
        // out through our network message stream.
        // TODO: Do something with the subscription disposable
        networkConnection.Subscribe(
            x =&gt; _networkMessageStream.OnNext(x),
            exception =&gt; _NetworkMessageError(networkConnection, exception),
            () =&gt; _NetworkConnectionClosed(networkConnection)
        );
    }


My question is, simply speaking, am I


going the wrong way by thinking of Rx as streams of T and 
is this considered an anti pattern/bad approach to what I am trying to do?
I don't think your approach is fundamentally wrong: Rx is all about exposing and responding to streams of data. I do wonder though if any of this is necessary; doesn't the Observable.Select method do essentially what you are trying to do?