可观察的 <byte[]> 转换

Question

How can I convert IObservable to byte[]?

I want to convert IObservable to a wav file and save it on the disk.

DisOutput d;
File.WriteAllBytes("outputsend.wav", d);

I have an array IObservable which I want to convert to byte[] so that I can write to a file. How can I convert IObservable to byte[] because WriteAllBytes takes byte[] as input

Answer 1

I assume that you have a framework that generates a WAV file on the fly in the form of an IObservable<Byte> . Presumably, when the generation is complete the IObservable<Byte> will fire OnCompleted to signal this.

IObservable<Byte> observable;

The simplest way to do what you want is to use ToList which will generate an IObservable<IList<Byte>> that fires when the source observable sequence completes:

observable.ToList().Subscribe(list => File.WriteAllBytes("outputsend.wav", list.ToArray());

What happens is that the ToList operator will collect all incoming bytes in a list that grows over time. When the incoming sequence completes the subscribers are notified and in this case the list of bytes is written to a file.

However, there is no need to buffer the bytes in memory. Instead they can be written directly to the file. It is important that the file is closed when the incoming stream of bytes completes and this can be achieved using this somewhat more complicated but also more efficient extension method:

static class ObservableExtensions {

  public static IObservable<Unit> WriteToFile(this IObservable<Byte> source, String fileName) {
    return Observable.Create<Unit>(
      observer => {
        var fileStream = new SerialDisposable();
        return new CompositeDisposable(
          source.Subscribe(
            value => {
              try {
                if (fileStream.Disposable == null)
                  fileStream.Disposable = File.Create(fileName);
                ((FileStream) fileStream.Disposable).WriteByte(value);
              }
              catch (SystemException ex) {
                observer.OnError(ex);
              }
            },
            observer.OnError,
            () => {
              observer.OnNext(Unit.Default);
              observer.OnCompleted();
            }
          ),
          fileStream
        );
      }
    );
  }

}

You can use this extension method like this:

observable.WriteToFile("outputsend.wav").Subscribe(_ => Console.WriteLine("Done"));

To handle errors you can use another overload of Subscribe :

observable.WriteToFile("outputsend.wav").Subscribe(
  _ => Console.WriteLine("Done"),
  ex => Console.WriteLine(ex)
);

This will write exceptions to the console. A more sophisticated approach would be required in a production quality application.