Teilen Sie einen Iobservable und kombinieren Sie dann nach der Verarbeitung?

Question

Nachdem ich mit Iobservables experimentiert hatte, habe ich beschlossen, sie für die Verarbeitung eingehender Nachrichten über einen Nachrichtenbus zu testen. Im Wesentlichen bekomme ich eine IObservable<Request> und die Request Enthält die erforderlichen Funktionen, um auf die Antwort zu antworten.

An einem Punkt während der Verarbeitung muss ich die Daten deserialisieren und sie von einer Anforderung in ein Befehlsobjekt konvertieren, das enthält, was sie tatsächlich tun müssen. Der Befehl bezieht sich nicht mit der Anfrage.

Nach der Deserialisierung verwandle ich es in die richtige Antwort, um die Antwort zu senden, benötige ich das ursprüngliche Anforderungsobjekt. Ich möchte versuchen, dies zu erreichen und gleichzeitig eine hohe Code -Lesbarkeit beizubehalten. Bisher habe ich Erweiterungsmethoden und Lambda -Ausdrücke verwendet, um die folgenden zu erhalten (wo requests ist der 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));  

Meine Frage ist, da alle Befehle vor dem Zip Funktion nehmen Zeit, um zu verarbeiten, wird das Zip Arbeiten Sie mit demselben Eingabefiel (dh der ursprünglichen Eingabe und auch auf der separaten verarbeiteten Eingabe), wenn ein konstanter Nachrichtenstrom vorliegt. Wie kann ich das testen?

Gibt es eine bessere Möglichkeit, dies zu tun?

Answer 1

Ich habe es zufriedenstellend gelöst, aber es kann eine bessere Methode geben. Ich habe einen monadisch-ähnlichen Typ erstellt, der zwei Typen komponiert: einen Wert, der die Daten sind, die transformiert werden; und ein Kontext, der die umgebenden Daten sind.

Es ist so etwas wie folgt:

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

Ich habe auch implizite Operatoren sowohl für den Kontext als auch für den Wert definiert. Es gibt auch einige zugeordnete Erweiterungsmethoden, mit denen Sie den Wert von einem Typ in einen neuen Typ umwandeln können.

Wenn jemand eine bessere Methode hat, begrüße ich Alternativen und ich werde dies für eine Weile unbeantwortet lassen.