New Release: Reactive Extensions v1.0.10425 RRS feed

  • General discussion

  • We are pleased to announce a new release of the Reactive Extensions (Rx).  This new release is an exciting step forward for Rx.  Not only will you find many new features and improvements, but you will also see that Rx has expanded its offerings.

    Beginning with this release, the Rx API will be offered in two forms: stable and experimental.  The experimental form of the API will continue to change and evolve at a rapid pace characterized by frequent iteration and constant improvement.  At the same time, the experimental portions of the API will be less documented and may change somewhat from release to release.  This offering is essentially what Rx is today.  Additionally, we will offer a subset of the API which is called the stable API.  This portion of the API will not significantly change and will be augmented by documentation, samples, and support.  If you want to try out and influence new features then use the experimental API.  If you want to take a dependency on Rx in an environment where stability is more important then use the stable API.  While the stable API will be available on many platforms, it will only be officially supported on .NET 4.0, Silverlight 4, and Windows Phone 7.

    In order to achieve a stable form of the API, we needed to make changes.  These changes include changing namespaces to System.Reactive, renaming types and operators, and a few other changes that we include in the release notes.  We understand that these changes may be a bit painful: we had to change all of our code, samples, and tests.  We also understand that many of the existing samples and videos will now contain out-of-date information and we will work hard to improve this situation.  Of course, you may continue to use the previous releases as described in their license, but when you make the investment to change you will gain a great deal.  You will be able to use the stable API, get bug fixes without API changes, and perhaps most importantly you will have access to full API documentation once the final release is available on MSDN Data Developer Center and on NuGet.

    Your feedback is vital.  Please try it out.  Kick the tires.  Let us know what you think.

    Thank you for innovating together with us in the past and we look forward to happy coding together in the future.


    The Rx Team


    Thursday, April 28, 2011 6:29 PM

All replies

  • Release Notes:

    • Fixed time delay in Window and Buffer operators
    • Fixed bug in GroupJoin
    • Fixed bug in Merge(n)
    • Renamed Window* to Window
    • Renamed Buffer* to Buffer
    • Renamed Generate* to Generate
    • Removed RemoveTimeInterval
    • Removed RemoveTimestamp
    • Removed Scan0
    • Removed Let on TValue
    • Ensured parity between Buffer and Window overloads, every overloads exists for both
    • Added absolute time scheduling to IScheduler
    • Renamed Join (as in the pattern) to When
    • Added overload to Sample that takes an IObservable
    • Moved TestScheduler to Microsoft.Reactive.Testing
    • Created ReactiveTest base type with useful members
    • Added state parameter to IScheduler schedule methods
    • Added additional overloads for First/Last/Single (OrDefault)
    • Added ElementAt
    • Added Distinct
    • Renamed FromEvent to FromEventPattern
    • Added FromEvent which converts from non-standard events to observables
    • Added ToEventPattern and IEventPatternSource
    • Added ToEvent and IEventSource
    • Improved performance of Task.ToObservable
    • Removed IEvent, Added EventPattern
    • Added ReactiveAssert class with common asserts in Microsoft.Reactive.Testing
    • Split release into Experimental and Stable
    •   - Stable is only available on .NET 4, SL 4, and WP7
    •   - Marked all parts of the API which are only available in Experimental with the ExperimentalAttribute
    • Improved Doc comments
    • Fixed a bug in Concat, OnErrorResumeNext, and Catch
    • Improved perf of subjects
    • Removed VirtualScheduler
    • Added VirtualTimeSchedulerBase, VirtualTimeScheduler
    • Added HistoricalSchedulerBase, HistoricalScheduler
    • Remove extended Action and Func Definitions in System.Reactive for downlevel platforms
    • Stopped shipping TPL 3.5
    • Temporarily not shipping System.Linq.Async, Ix, and RxJS
    • Added documentation for Microsoft.Reactive.Testing
    • Changed IScheduler interface, there are new extension methods on Scheduler which expose the old methods, but implementors will need to change; recursive and distributed scheduling
    • New Assembly structure:
    •   - System.Reactive (what used to be CoreEx and Reactive)
    •   - System.Reactive.Providers (Qbservable, IQbservable, and IQbservableProvider) - Observable.Provider is now Qbservable.Provider
    •   - System.Reactive.Windows.Forms (all operators, schedulers, etc related to Windows Forms)
    •   - System.Reactive.Windows.Threading (all operators, schedulers, etc related to WPF)
    •   - Microsoft.Reactive.Testing (all code to assist in writing tests)
    • Third-party Qbservable extensibility
    • New namespace structure:
    •   - System
    •     - Reactive
    •       - Linq
    •       - Disposables
    •       - Concurrency
    •       - Joins
    •       - Subjects
    •       - Threading
    •         - Tasks
    •       - Windows
    •         - Threading
    •         - Forms
    •   - Microsoft
    •     - Reactive
    •       - Testing
    • MutableDisposable changed to take an assignment policy
    • Reduced the memory consumption of CurrentThreadScheduler, VirtualTimeScheduler, HistoricalScheduler, and EventLoopScheduler
    • Reduced the memory consumption of many operators
    • Added Unit.Default
    • Added static class Subject with a few operators for Subjects
    • Removed CurrentThreadScheduler.EnsureTrampoline, Added CurrentThreadScheduler.ScheduleRequired
    • Added Observer.Synchronize
    • Made IObservable compatible with new Async CTP in the Experimental subset
    • Using await on IObservable now only returns the last message, if you want the old behavior use ToList first
    • Replaced all Subject* with FastSubject*, if you want old behavior then create a subject and use the Subject.Synchronize operator
    • Removed publish overloads that take a scheduler

    Thursday, April 28, 2011 6:45 PM
  • This is a big one!

    FYI - A number of teams I've worked with have taken on Ix. Will be a blocker for them adopting this release in the short term.


    James Miles
    Thursday, April 28, 2011 8:23 PM
  • We plan on shipping it again soon.  It is a side-effect of recently extensively changing our build system.  We haven't ported all of the projects to the new system yet.

    Yes, this one is a big one.  If people want to continue using old builds for awhile that is great.  This release is really about moving to a form of the API that we want for the long term.

    Thursday, April 28, 2011 8:41 PM
  • Hi Wes!

    Exciting news indeed! However, I am probably blind or thick (perhaps both :) ), but where do I find this new drop? From what I can gather, the download link on the Rx page points to the previous release??? Oh yeah, that is another thing - from the dl links where can I see what version number I am downloading???

    Niels | @nielsberglund
    Friday, April 29, 2011 4:41 AM
  • You are neither blind nor thick ;)  We are still in the process of updating NuGet and Microsoft Download Center.  We also haven't yet put the link up to the stable version of the release or the new SL 5 release.

    You can find links to all of the experimental versions (minus SL 5) at  When you download and run the installer, it very prominently displays the version number.

    If we haven't sorted out everything tomorrow then I'll post links to all of the releases here in the interim.

    Friday, April 29, 2011 7:01 AM
  • Hi I am not able to find System.Threading.DLL for the .NET 3.5 version. Is this a bug? A collegue of mine told me that previous release was including it. The current one does not.

    I am running Win7 Enterprise x64

    Thank you!

    Friday, April 29, 2011 12:38 PM
  • Ok, download center is now updated.  You can grab both the experimental and stable bits from there.  For those who still need Ix, Linq.Async, System.Threading.DLL or other such stuff they can download version v1.0.2856.0.


    I'll work on updating NuGet and the Data Developer Center webpage.  Thanks for your patience.

    Friday, April 29, 2011 2:59 PM
  • Are you continuing development on the Ix, Linq.Async, System.Threading.DLL libraries?

    Thanks - Jordan

    Friday, April 29, 2011 3:02 PM
  • Basically in my case I need to know the actual reason Px extensions (ie. Parallel.ForEach), previously included in v1.0.2856.0. I mean, is it only bcs this new version is experimental, so, focused on Rx only, -or- should we assume that from 1.1 version the same are not included anymore?


    Friday, April 29, 2011 3:10 PM
  • We will continue to develop Ix and Linq.Async but we have no current plans to have them in the planned stable release.

    We never developed System.Threading.DLL, but only included it for backwards compat.

    Friday, April 29, 2011 4:28 PM
  • Hi,

    Where is the documentation? Was it removed from the install package?



    Saturday, April 30, 2011 11:09 PM
  • Dear,


    After following the Microsoft Techdays in Belgium last week (nice presentation by Bart De Smet by the way), I was planning to start playing with Rx. After downloading the new version and start reading the hands on lab documentation I could not find back the reference "System.CoreEx.dll". Any idea how this comes? I'm using Visual Studio 2010 Professional. I could find back "System.Reactive.dll" in the folder "C:\Program Files\Microsoft Reactive Extensions SDK\v1.0.10425\Binaries\.NETFramework\v4.0"

    Thank's for your help.

    Sunday, May 1, 2011 9:18 PM
  • Eeek! Why was TPL 3.5 removed?

    Shipping the TPL in 3.5 was a godsend. Removing it will cause me a heap of heart-ache. Can its exclusion be commented on please?



    James C-S
    Monday, May 2, 2011 3:14 AM
  • Thanks Rx Team!

    What is the strategy for Observable.Iterate? Completely avoid now and go with the async/await?

    The removal of Ix is a real frustration; hopefully the parts I am using I can dummy up myself since this is connected in with async CTP SP1 etc. (I've come too far)

    Regards, Fil.


    Regards, Fil.
    Monday, May 2, 2011 6:09 AM
  • Where is the documentation?

    This release is a preview of the stable/experimental structure of Rx.  Consider it RC 0 for Rx.  The documentation is currently being written and will be available once the final release of v1.0 is made public.

    Where is System.CoreEx.dll?

    We have removed System.CoreEx.dll in favor of combining it with System.Reactive.dll.  The only things which are excluded from that assembly are things which do not exist on all platforms (Expressions, Win Forms, and WPF).

    Why was TPL 3.5 removed?

    You can continue to use TPL 3.5 from an older release.  We have not made any changes to it and so all releases of TPL v3.5 are the same.

    Where is Ix and Linq.Async?

    They were removed temporarily from the project since our focus was on getting things that will appear in the stable release in their final form.  We do not plan to offer Ix and Linq.Async in a stable release at the current time.  We may offer them in the experimental release or perhaps as a separate download.  We will investigate this.  If you have any feedback on what would be most helpful here let us know.

    What about Observable.Iterate?

    Use the Observable.Create that takes a Func<IObserver<...>, Task> which works exactly the same as Iterate except that it uses async await to drive it.

    Tuesday, May 3, 2011 12:47 AM
  • Regarding Observable.Iterate, I can't see an Observable.Create with this overload. I only see:

    public static IObservable<TSource> Create<TSource>(Func<IObserver<TSource>, IDisposable> subscribe);
    public static IObservable<TSource> Create<TSource>(Func<IObserver<TSource>, Action> subscribe);

    (a great solution to create a Observable.Create overload as a replacement to Observable.Iterate BTW!)

    Regards, Fil.
    • Edited by Fil Mackay Tuesday, May 3, 2011 12:53 AM
    Tuesday, May 3, 2011 12:50 AM
  • The Observable.Create overload that I referred to is only in the experimental release until they finalize the await pattern for .NET 4.5.
    Tuesday, May 3, 2011 12:52 AM
  • Thanks Wes, just realised I don't see any Experimental attributes anywhere; am I looking at the right place? I downloaded the latest build, is there a special download for the experimental bits, if not - where are they :)


    Regards, Fil.
    Tuesday, May 3, 2011 12:57 AM
  • Here is the experimental release: couldn't find it, other than to Google "Rx Experimental Release" :)


    Regards, Fil.
    Tuesday, May 3, 2011 1:03 AM
  • The Observable.Create overload that I referred to is only in the experimental release until they finalize the await pattern for .NET 4.5.

    What about an additional overload (this is actually what I need):

    public static IObservable<TResult> Create<TResult>(Func<Task<TResult>> asyncMethod);
    This would serially call asyncMethod, passing on all the returned values to the observer. When it returns null, the observer is completed.

    Regards, Fil.


    Regards, Fil.
    Tuesday, May 3, 2011 2:00 AM
  • Where is the documentation?

    This release is a preview of the stable/experimental structure of Rx.  Consider it RC 0 for Rx.  The documentation is currently being written and will be available once the final release of v1.0 is made public.

    Will the documentation containing marble diagrams to explain how the operators work? The previous sentences are dose not explain how an operator works. You have need to understand the operator before you read the documentation.
    Tuesday, May 3, 2011 4:12 AM
  • Actually, scratch this - the existing overloads were fine. I ended up with:



        public static IObservable<byte[]> AsyncRead(this Stream stream, int bufferSize = 1 << 16)
          return Observable.Create<byte[]>(async (observer, cancelToken) =>
            var buffer = new byte[bufferSize];
            while (!cancelToken.IsCancellationRequested)
              var bytesRead = await stream.ReadAsync(buffer, 0, bufferSize);
              if (bytesRead == 0)
                // End of file
              // return read data
              var outBuffer = new byte[bytesRead];
              Array.Copy(buffer, outBuffer, bytesRead);


    Regards, Fil.
    Tuesday, May 3, 2011 5:30 AM
  • The documentation will contains conceptual and references docs.  For operators, there will be explanations and samples much like you get for the standard query operators in LINQ.  If you have particular requests, I know that our doc writers are very interested in hearing from the community about what would be the most useful information to cover and where to focus their energy.

    Tuesday, May 3, 2011 6:35 AM
  • Perfect!  As a side note, you don't need the observer.OnCompleted before the break since that will be executed automatically.
    Tuesday, May 3, 2011 6:36 AM
  • Great, I wondered about that - thanks.

    Might be worth thinking about changing this signature then to provide an Action<T> rather than IObserver<T> since you are only supposed to call OnNext?


    Regards, Fil.
    Tuesday, May 3, 2011 6:40 AM
  • It is not incorrect to call observer.OnCompleted just unnecessary.  In cases where you want to do processing after calling OnCompleted (or OnError for that matter) you will need to do that explicitly.  If you make additional calls to observer.OnNext/OnCompleted/OnError then they will be ignored.
    Tuesday, May 3, 2011 6:43 AM
  • Are there change notes anywhere? I'm having trouble finding Observable.ForkJoin anywhere in the new namespace. Did it get replaced? (removed, renamed, etc)
    Wednesday, May 4, 2011 5:32 PM
  • Looks like I missed a note.  Use CombineLatest or Zip instead of ForkJoin.
    Wednesday, May 4, 2011 8:06 PM
  • I think you may have forgotten to mark System.Reactive.dll as CLS-Compliant.  Could you mark it for the next release?

    Thursday, May 5, 2011 12:39 AM
  • Yes, we will.
    Thursday, May 5, 2011 1:51 AM
  • I think I may have found a bug. While updating the F# wrapper project, FSharp.Reactive, I noticed that a previously passing test now fails. The test verifies that a F# function wrapped in an Action delegate can be used to subscribe to an observable. The test fails with the following message:

    Errors and Failures:

    1) Test Failure : ReactiveSpecs.When subscribing to an observable async workflow, it should only raise one item before completion.


    Elements are not equal.


    But was: 0


    at NaturalSpec.Utils.check[a](AssertType assertType, Object a, Object b, a value) in D:\Builds\NaturalSpec\master\src\app\NaturalSpec\Utils.fs:line 65

    at NaturalSpec.Syntax.should[a,b,c,d,e](FSharpFunc`2 f, a x, b y) in D:\Builds\NaturalSpec\master\src\app\NaturalSpec\Syntax.fs:line 115

    at ReactiveSpecs.When subscribing to an observable async workflow\, it should only raise one item before completion-@45.Invoke(FSharpFunc`2 f, Int32 x, Int32 y) in .\src\FSharp.Reactive.Tests\ObservableSpecs.fs:line 45

    at ReactiveSpecs.When subscribing to an observable async workflow, it should only raise one item before completion.() in .\src\FSharp.Reactive.Tests\ObservableSpecs.fs:line 43


    2) Test Error : ReactiveSpecs.When subscribing to an observable event, it should raise three items.

       System.ArgumentException : Error binding to target method.

       at System.Delegate.CreateDelegate(Type type, Object firstArgument, MethodInfo method, Boolean throwOnBindFailure)

       at System.Reactive.Linq.Observable.<>c__DisplayClass2c0`2.<FromEvent>b__2be(IObserver`1 observer)

       at System.Reactive.AnonymousObservable`1.<>c__DisplayClass1.<Subscribe>b__0()

       at System.Reactive.Concurrency.Scheduler.Invoke(IScheduler scheduler, Action action)

       at System.Reactive.Concurrency.ScheduledItem`2.InvokeCore()

       at System.Reactive.Concurrency.ScheduledItem`1.Invoke()

       at System.Reactive.Concurrency.CurrentThreadScheduler.Trampoline.Run()

       at System.Reactive.Concurrency.CurrentThreadScheduler.Schedule[TState](TState state, TimeSpan dueTime, Func`3 action)

       at System.Reactive.Concurrency.CurrentThreadScheduler.Schedule[TState](TState state, Func`3 action)

       at System.Reactive.AnonymousObservable`1.Subscribe(IObserver`1 observer)

       at System.ObservableExtensions.Subscribe[TSource](IObservable`1 source, Action`1 onNext)

       at ReactiveSpecs.listening with@15TT.Invoke(FSharpFunc`2 f, IEnumerable`1 lst, IObservable`1 obs) in .\src\FSharp.Reactive.Tests\ObservableSpecs.fs:line 17

       at ReactiveSpecs.When subscribing to an observable event\, it should raise three items-@27-2.Invoke(IObservable`1 arg20) in .\src\FSharp.Reactive.Tests\ObservableSpecs.fs:line 27

       at ReactiveSpecs.When subscribing to an observable event, it should raise three items.() in .\src\FSharp.Reactive.Tests\ObservableSpecs.fs:line 26


    Is this expected behavior? If so, how can I use F# with Rx?

    Ryan Riley @panesofglass
    Tuesday, May 17, 2011 4:16 AM
  • Is there a replacement for Observable.Run?
    Wednesday, May 18, 2011 6:26 PM
  • Could you guys push out a new Ix soonish?

    We can't link to the new Rx and old Ix at the same time, right? (there will be duplicate defs for IScheduler, etc).


    Wednesday, May 18, 2011 8:58 PM
  • Is there a replacement for Observable.Run?
    It's called Obsevable.ForEach() now.
    Regards, Fil.
    Wednesday, May 18, 2011 10:07 PM
  • Ryan,

    Can you give me a minimal repro?

    Tuesday, May 24, 2011 11:20 PM
  • Ryan,

    Can you give me a minimal repro?

    Ah, sorry; I meant to include the link to the project:

    Specific test cases are at

    Ryan Riley @panesofglass
    Wednesday, May 25, 2011 2:53 AM
  • Hi Wes,

    You mentioned a while ago that the team would be looking into providing official F# support for Rx. Can we expect this support in the near future?



    Thursday, May 26, 2011 11:14 AM
  • Looks like I might be mistaken. I didn't think I was using anything tricky in my tests, but fsi appears to work fine. I'll re-evaluate what I have in my repo. It's interesting that the tests worked in the previous version, but with the recent changes I made, it could be something else that's causing the test failure.

    > #r @"C:\Program Files (x86)\Microsoft Reactive Extensions SDK\v1.0.10425\Binaries\.NETFramework\v4.0\System.Reactive.dll";;
    --> Referenced 'C:\Program Files (x86)\Microsoft Reactive Extensions SDK\v1.0.10425\Binaries\.NETFramework\v4.0\System.Reactive.dll'
    > open System;;
    > open System.Reactive;;
    > open System.Reactive.Linq;;
    > Observable.Range(0,3).Subscribe(Action<_>(printfn "%d"));;
    val it : IDisposable =
      {Disposable = null;}

    Ryan Riley @panesofglass
    Friday, May 27, 2011 6:31 AM
  • "Temporarily not shipping System.Linq.Async, Ix, and RxJS"

    Is RxJS dead?  I have not seen any recent RxJS activity on the MSDN blogs.


    Update to my own question, this is a message from Matthew Podwysocki  on the KnockoutJS forum:

    "It's far from dead at this point and I'm hard at work making sure that
    RxJS is a nice mirror of Rx.Net.  This included a whole suite of tests
    as well.  Rx.Net has changed quite a bit in the past couple of months
    and I'm the developer on this project at the moment, so please bear
    with us.  Once the Schedulers have been rewritten, the rest should
    easily fall into place."



    Friday, May 27, 2011 12:53 PM
  • I miss the Observable.ForkJoin too...

    Do you have more information yet?

    Thursday, July 14, 2011 8:40 PM