¿Dividir un IOBServable y luego combinar después del procesamiento?

Question

Después de experimentar con IOBServables, decidí probarlos para el procesamiento de mensajes entrantes a través de un bus de mensajes. Esencialmente obtengo un IObservable<Request> y el Request Contiene las funciones necesarias para responder a la respuesta.

En un punto durante el procesamiento, tengo que deserializar los datos y convertirlos de una solicitud a un objeto de comando que contenga lo que realmente necesita hacer. El comando no está relacionado con la solicitud.

Después de deserializarlo, lo transformo en la respuesta adecuada, sin embargo, para enviar la respuesta necesito el objeto de solicitud original. Quiero intentar lograr esto mientras mantengo una alta legibilidad de código. Hasta ahora he usado métodos de extensión y expresiones lambda para obtener lo siguiente (dónde requests es el 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));  

Mi pregunta es, ya que todos los comandos antes del Zip la función toma tiempo para procesar, ¿la voluntad Zip Opere con el mismo objeto de entrada (es decir, la entrada original, y también en la entrada procesada separada) si hay una secuencia constante de mensajes. ¿Cómo puedo probar esto?

¿Hay una mejor manera de hacer esto?

Answer 1

Lo he resuelto satisfactoriamente, sin embargo, puede haber un mejor método. Creé un tipo monádico que compone dos tipos: un valor que son los datos que se están transformando; y un contexto que son los datos circundantes.

Es algo como lo siguiente:

 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;
       }
  }

También definí operadores implícitos tanto para contexto como para el valor. También hay algunos métodos de extensión asociados que le permiten transformar el valor de un tipo a un nuevo tipo.

Si alguien tiene un método mejor, aunque doy la bienvenida a las alternativas, y voy a dejar esto sin respuesta por un tiempo.