Divida um IOBServable e depois combine após o processamento?

Question

Depois de experimentar o IOBServables, decidi testá -los quanto ao processamento de mensagens recebidas em um barramento de mensagens. Essencialmente eu recebo um IObservable<Request> e a Request Contém as funções necessárias para responder à resposta.

Em um ponto durante o processamento, tenho que desapealizar os dados e convertê -los de uma solicitação em um objeto de comando que contém o que ele realmente precisa fazer. O comando não está relacionado à solicitação.

Depois de desertizá -lo, transformto -o na resposta adequada, no entanto, para enviar a resposta, preciso do objeto de solicitação original. Quero tentar conseguir isso, mantendo a alta legibilidade do código. Até agora, usei métodos de extensão e expressões de lambda para obter o seguinte (onde requests é o IObservable<Request>):

requestProcessor = requests
            .Deserialize<IdentityRequest>()
            .Where(idRequest => idRequest.Address != null)
            .Select(idRequest => new IdentityResponse() {Identity = identityTable[idRequest.Address.Address]})
            .Serialize()
            .Zip(requests, (response, request) => new {request = request, response = response})
            .Subscribe(data => data.request.Respond(data.response, ObjectTypes.IdentityResponse));  

Minha pergunta é, já que todos os comandos antes do Zip função levar tempo para processar, será o Zip Opere no mesmo objeto de entrada (por exemplo, a entrada original e também na entrada processada separada) se houver um fluxo constante de mensagens. Como posso testar isso?

Existe um jeito melhor de fazer isso?

Answer 1

Eu resolvi isso de maneira satisfatória, mas pode haver um método melhor. Criei um tipo de monádico que compõe dois tipos: um valor que é os dados que estão sendo transformados; e um contexto que é os dados circundantes.

É algo como o seguinte:

 public class ComposedType<TValue, TContext>
 {
       public TValue Value { get; protected set; }
       public TContext Context { get; protected set; }

       public ComposedType(TValue value, TContext context)
       {
            Value = value;
            Context = context;
       }
  }

Eu também defini operadores implícitos para o contexto e o valor. Existem também alguns métodos de extensão associados que permitem transformar o valor de um tipo em um novo tipo.

Se alguém tiver um método melhor, eu acolhe as alternativas e vou deixar isso sem resposta por um tempo.