Announcements/Tags/Announcement

hide:
- toc

Posts tagged "Announcement"

<header class="md-post__header">
<h3 class="md-post__title">ReactiveUI Association, Inc.</h3>
</header>

<time datetime="2021-01-04">January 4, 2021</time> — Rodney Littles, II

Open Source Sustainability has become a big topic in the .NET community. With several Open Source projects having issues with long term sustainability, the ReactiveUI team has been identifying ways to address the long term sustainability of our open-source software. Our main goal is to make sure that as .NET grows and evolves that Reactive Programming and ReactiveUI evolve and grow with it. We have started to talk about strategies to ensure that ReactiveUI has maintenance and growth for the future.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">ReactiveUI Rebranding</h3>
</header>

<time datetime="2019-01-20">January 20, 2019</time> — Artyom Gorchakov

ReactiveUI was created by Anaïs Betts whilst working in Office Labs at Microsoft, and released in early 2011. Since that time, ReactiveUI has become a mature framework trusted by Slack, GitHub, Amazon, Elastic and Microsoft, has become a member of the Dot Net Foundation, and actively maintained by the open-source community on GitHub. The work we do is sponsored by our wonderful Backers on Reactive Marbles.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">Removing ReactiveCommand abstract base class</h3>
</header>

<time datetime="2018-11-07">November 7, 2018</time> — Rodney Littles, II

The ReactiveUI team has been urging consumers for some time now to move away from the ReactiveCommand abstract class for properties. There are some slight nuiances with type constraints that can sometimes cause run time bugs. Because your property can resolve to an abstract base implementation doesn't mean you should define it that way. We are very adamante about creating a type safe environment where consumers don't have to worry about hidden runtime issues with the framework. RFC: Remove ReactiveCommand abstract base class was raised to address this exact issue.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">ReactiveUI Succession Update</h3>
</header>

<time datetime="2018-08-28">August 28, 2018</time> — Rodney Littles, II

ReactiveUI has released several minor versions since 8.0. Some of the most recent versions have been released without Geoff having to push code, or prep issues. This is thanks to members of the core team, and community members who have stepped up to move the project forward. Glenn Watson has started to play a large role in the maintenance of ReactiveUI. There have been other's getting involved in enhancing some of the platform logic, and documentation. Community members have been identifying and resolving issues that help make our framework better. What does this mean for ReactiveUI succession? It's happening. What does that mean for you? It means we are working on ways to improve ReactiveUI and make it easier to consume. We have several initiatives on the team and there are a few RFC's planned for the 9.0 release that might be of interest.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">Deprecating ReactiveList</h3>
</header>

<time datetime="2018-08-13">August 13, 2018</time> — Rodney Littles, II

With the coming 8.6.1 release, ReactiveList will be marked as deprecated. ReactiveList is being replaced by Roland Pheasants Dynamic Data
Announcement

<header class="md-post__header">
<h3 class="md-post__title">Memory Leak Detection</h3>
</header>

<time datetime="2018-05-15">May 15, 2018</time> — Geoffrey Huntley

Moments ago we merged a contribution by Grzegorz Kotfis that adds another layer of protection before the project moves towards automated continuous delivery. The pull-request added a new project called ReactiveUI.LeakTests which allows the maintainers to specify tests that can determine memory leaks by checking memory usage for objects of a particular type, or tests that track memory traffic and fail in case the traffic exceeds some threshold.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">ReactiveUI Succession</h3>
</header>

<time datetime="2018-05-14">May 14, 2018</time> — Rodney Littles, II

OSS project maintainers have a serious load on their shoulders. They are responsible for authoring and maintaining tools that enable developers to deliver business value faster and easier. Gone are the days where a developer has to start every project by defining their own IO, data structures and sub routines. Modern developers rely on frameworks, third party libraries and other niceties that use to take hundreds of developer man hours before writing any business logic. Being a maintainer, and focusing that level of effort is a labour of love, but a labour not the less.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">.NET Core 3 and ReactiveUI</h3>
</header>

<time datetime="2018-05-07">May 7, 2018</time> — Geoffrey Huntley

At Microsoft Build Live today, Microsoft [shared a first look at their plans](
Announcement

<header class="md-post__header">
<h3 class="md-post__title">Delisting of versions before 8.0.0 from NuGet</h3>
</header>

<time datetime="2018-05-04">May 4, 2018</time> — Geoffrey Huntley

As part of the v8.0.0 release, ReactiveUI changed the field separator used in our package names from dashes to periods which is the standard convention used in dotnet. It was a breaking change, and our documentation was updated as part of the release to provide you with instructions of which package is needed for every platform.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">System.Reactive has a new home on GitHub</h3>
</header>

<time datetime="2018-05-03">May 3, 2018</time> — Geoffrey Huntley

At MVP Summit, the community met with Microsoft and with their support and encouragement the community forked control of System.Reactive. Over the last couple weeks some of the smartest brains from multiple ecosystems have united in our Slack instance to plan for the future.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">Moving towards VSTS and continuous deployment</h3>
</header>

<time datetime="2018-05-02">May 2, 2018</time> — Geoffrey Huntley

Howdy folks,
Announcement

<header class="md-post__header">
<h3 class="md-post__title">The future of System.Reactive</h3>
</header>

<time datetime="2018-04-30">April 30, 2018</time> — Geoffrey Huntley

The last official release of System.Reactive by Microsoft was back in 2014. On the 16th of June 2016 Oren Novotny (with the help of Bart De Smet) moved Rx/Ix into the .NET Foundation.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">You, I, and ReactiveUI</h3>
</header>

<time datetime="2018-04-22">April 22, 2018</time> — Kent Boogaart

I'm elated to finally announce the launch of my book, _You, I, and ReactiveUI_. This has been a labor of love, and I'm sure you'll be as happy as I am with the result. You can find out more at https://kent-boogaart.com/you-i-and-reactiveui/.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">Run a meetup? Are you looking for presenters?</h3>
</header>

<time datetime="2017-09-13">September 13, 2017</time> — Geoffrey Huntley

Announcing something pretty special today; I'm not sure if anyone has done this before so here we go.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">The public API surface of ReactiveUI is now protected by API approval tests</h3>
</header>

<time datetime="2017-09-07">September 7, 2017</time> — Geoffrey Huntley

When reviewing pull requests the maintainers used to manually eyeball the changes proposed in a pull-request to determine if there was a change to the public API surface. We now have new tests, one per platform that trip when the public API surface changes for that platform.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">Assemblies are now code signed with the .NET Foundation certificate</h3>
</header>

<time datetime="2017-09-05">September 5, 2017</time> — Geoffrey Huntley

Thanks to a legendary contribution from Oren Novotny, all ReactiveUI assemblies from v8.0.0-alpha73 and onwards are code signed with the .NET Foundation certificate. Identity signing of the assemblies means that you can verify the authenticity of the binaries used in your application and ensure they have not been tampered with as only assemblies compiled via the .NET Foundation CI infrastructure are signed with this certificate.
Announcement

<header class="md-post__header">
<h3 class="md-post__title">Automatic closure of stale GitHub issues</h3>
</header>

<time datetime="2017-08-25">August 25, 2017</time> — Geoffrey Huntley

One of the perks of being a maintainer of an open-source project is you get to be part of the fantastic initiative by GitHub - maintainers.github.com where some of the brightest minds in open-source leadership from across disciplines/ecosystems share their insights on how to run projects, productively at scale towards successful outcomes.
Announcement

Announcements/2017 08 25 Automatic Closure Of Stale Github Issues

NoTitle: true
IsBlog: true
Title: Automatic closure of stale GitHub issues
Tags: Announcement
Author: Geoffrey Huntley
Published: 2017-08-25

One of the perks of being a maintainer of an open-source project is you get to be part of the fantastic initiative by GitHub - maintainers.github.com where some of the brightest minds in open-source leadership from across disciplines/ecosystems share their insights on how to run projects, productively at scale towards successful outcomes.

One of the lessons we have learned from that community is that having stale issues (or pull-requests) is a source of contention for both maintainers and consumers of software.

Moments ago we enabled probot/stale on our GitHub repository. What this means is a friendly robot will automatically close any open GitHub issue (including pull-request) with more than sixty-seven days of inactivity. Eighty-five issues were visited by the robot and it asked the initiators what the status is - automatically. As a maintainer, it always feels awkward closing old issues or half-completed pull requests. We haven't always been the best with triaging and this is the first step of many to improve in this area.

I've gone through by hand and where appropriate marked some of them to never be automatically closed (legitimate bugs or outstanding pull-requests), but if I've missed one, please accept our apologies if your contribution has not been attended to properly and perform some form of activity (comment, label, assign to milestone) to reset the clock.

As is always with open-source, if you want an issue progressed faster please start talks with a maintainer with how you can help out. There are so many ways to contribute to open-source and the most valued are often not code related. We are always looking for more help and look after those who stick around. Say howdy to one of the maintainers or browse reactiveui.net/contribute for ideas on where to start your journey.

Thank-you

Announcements/2017 09 05 Assemblies Are Now Code Signed With The Dotnet Foundation Certificate

NoTitle: true
IsBlog: true
Title: Assemblies are now code signed with the .NET Foundation certificate
Tags: Announcement
Author: Geoffrey Huntley
Published: 2017-09-05

Thanks to a legendary contribution from Oren Novotny, all ReactiveUI assemblies from v8.0.0-alpha73 and onwards are code signed with the .NET Foundation certificate. Identity signing of the assemblies means that you can verify the authenticity of the binaries used in your application and ensure they have not been tampered with as only assemblies compiled via the .NET Foundation CI infrastructure are signed with this certificate.

Announcements/2017 09 07 The Public Api Surface Of Reactiveui Is Now Protected By Approval Tests

NoTitle: true
IsBlog: true
Title: The public API surface of ReactiveUI is now protected by API approval tests
Tags: Announcement
Author: Geoffrey Huntley
Published: 2017-09-07

When reviewing pull requests the maintainers used to manually eyeball the changes proposed in a pull-request to determine if there was a change to the public API surface. We now have new tests, one per platform that trip when the public API surface changes for that platform.

These tests will provide contributors to ReactiveUI instant feedback (by failing) if the public API surface changes. Right now only Blend, WPF, Winforms, NET452, Testing are covered but in the future, once our CI practices evolve this will grow to include iOS, Mac, UWP and Android. One of the super-cool things about doing this is it provides a versioned changelog of when the public contracts change.

When the tests run, a file called ApiApprovalTests.{TestName}.received.txt is generated and compared to the "approved" file (ApiApprovalTests.{TestName}.approved.txt). If a change is found the test will fail. If the change is desired, replace the old "approved" file with the new "received" file and commit this and the test will pass. Pretty cool huh?

Announcements/2017 09 13 Run A Meetup Are You Looking For Presenters

NoTitle: true
IsBlog: true
Title: Run a meetup? Are you looking for presenters?
Tags: Announcement
Author: Geoffrey Huntley
Published: 2017-09-13

Announcing something pretty special today; I'm not sure if anyone has done this before so here we go.

Do you run a #xamarin / #uwp / @dotnetfdn meetup?- Are you looking for presenters? - We will come to you https://t.co/UETc27f1uS pic.twitter.com/CUZYeVmRrH— Geoffrey Huntley (@GeoffreyHuntley) September 14, 2017

TL;DR

Do you run a #xamarin / #uwp / #dotnet meetup?
Are you looking for presenters?
We will come to you [meet up co-host]()

Announcements/2018 04 22 You I And Reactiveui

NoTitle: true
IsBlog: true
Title: You, I, and ReactiveUI
Tags: Announcement
Author: Kent Boogaart
Published: 2018-04-22

I'm elated to finally announce the launch of my book, _You, I, and ReactiveUI_. This has been a labor of love, and I'm sure you'll be as happy as I am with the result. You can find out more at https://kent-boogaart.com/you-i-and-reactiveui/.

Announcements/2018 04 30 The Future Of System Reactive

NoTitle: true
IsBlog: true
Title: The future of System.Reactive
Author: Geoffrey Huntley
Tags: Announcement
Published: 2018-04-30

The last official release of System.Reactive by Microsoft was back in 2014. On the 16th of June 2016 Oren Novotny (with the help of Bart De Smet) moved Rx/Ix into the .NET Foundation.

At MVP Summit, the community met with Bart and with his support+encouragement we forked control of the project. Forking allows Bart to focus on working on the successor of System.Reactive - Reactor - which is kind of like Microsoft Orleans and Service Fabric. We hope this also creates capacity so Bart can work towards releasing Reactor as open-source and building an open-source community around it.

One of the most frustrating aspects of the backstory of System.Reactive on .NET is that it has been kicked around various factions of Redmond over the years, never owned by a product group or transitioned into a supported product by devdiv. The community would love to see System.Reactive transitioned into an officially supported product that is fully documented and made more accessible by the cloud developer advocate team.

It has always perplexed the reactive community as to why System.Reactive hasn't been invested into when the financial sector is built upon this technology. They use ReactiveUI + System.Reactive to build their desktop applications. Customers use System.Reactive as their backbone for their event processing backends. Investing in Rx/Ix is an easy way and fast way to light up even more Azure consumption.

¯\_(ツ)_/¯

Okay, so enough backstory - over the last week many folks in the community responded to the call to action on Twitter and here's what we think the next steps should be:

You may notice a central theme here - make it more accessible and safer for folks to contribute to the project. We would love to do a performance pass but not before these basics are crossed off. I'd like to take this time to point out that System.Reactive is still a solid and fine way to build your applications, now and into the future. It's mature, stable but it could be better. So the community is going to make it so.

We are centralising everything to-do with System.Reactive on the ReactiveUI brand as it has the most vibrant, active community and the maintainers have the most skin the game. Please join the conversation over at ReactiveUI Slack Channel in #rxnet and please consider financially supporting the community or If you can't (or won't) help out financially, then please donate your time.

Announcements/2018 05 02 Moving Towards Vsts And Continuous Deployment

NoTitle: true
IsBlog: true
Title: Moving towards VSTS and continuous deployment
Tags: Announcement
Author: Geoffrey Huntley
Published: 2018-05-02

Howdy folks,

It took us eight months to ship ReactiveUI 8.0.0 and to be frank that was way too long. It caused an immeasurable amount of stress that I don't want to ever experience again. It also lost us many users and new contributors/maintainers who could have helped out. We need to make releases an everyday thing with reduced risk and not a once in a blue moon thing with excessive risk.

Currently, ReactiveUI has two branches - develop and master. We intend to get rid of the develop branch and only have master. This ensures that maintainers are getting timely feedback from the community about quality and it provides assurances to contributors that time invested into contribution will have a fast ROI.

Ultimately our goal as an open-source project is to reduce the burden on our maintainers and ensure that there are no single points of failure in leadership. By investing in the experience of our contributors, we are investing in people who someday may become maintainers of ReactiveUI.

Once the end-to-end integration tests ship it opens up a world of possibility where the project can increase velocity without sacrificing quality. Done correctly it will ensure contributors receive immediate value for digging in and helping the project.

If a consumer is ever "blocked" by a fault in the framework, then the maintainers can have an open and honest discussion requesting the consumer to submit a pull-request to master. This pull-request will automatically generate binaries that the maintainers can use to perform validation (in addition to our automated test suite).

Maintainers operate under the rule that only pull-requests that are ready for shipping to production are merged. If the feature requires coordination with multiple parties and multiple attempts, then maintainers can work in a feature branch that once complete is merged to master as soon as possible. Feature branches will also generate binaries.

If something is merged that is later found to have caused a regression the immediate course of action for maintainers of ReactiveUI will be to revert the commit and ship a new release. The maintainers then can take as much time as needed to revisit why the regression occurred, resolve it and implement controls to ensure it doesn't happen again. In case that wasn't clear, we roll forward. Always.

Consumers will no longer need to configure the MyGet feed because we are now deploying to NuGet on a regular basis. Maintainers and contributors will still need to configure MyGet as that is where all build artifacts for unmerged code will land.

We intend to achieve this by moving away from AppVeyor as our needs have outgrown what they can currently offer. ReactiveUI needs to implement automated end-to-end tests that run as desktop apps and mobile apps on multiple operating systems. VSTS has powerful build matrixes that make this a walk in the park.
We intend to reduce the complexity of our build.cake by removing all release functionality and instead embracing the release management features of VSTS.
We are NOT moving our source control or issue management to VSTS as GitHub is where the community is.

The .NET Foundation provides it's member projects with a subsidized VSTS instance and Oren Novotny has volunteered to configure everything for us but if you want to help out I'm sure he would be keen to pair with you. Step up soon however as he _really_ wants to ship these improvements and if you delay you might just miss the boat.

I believe these changes will provide the following benefits:

Reduced cycle time from pull-request raised until release meaning that people receive value sooner.
A reduction in cognitive overhead and stress for maintainers by automating manual tasks and allow them to implement an aggressive issue ageing policy.
An increase in first-time contributors.
An increase in repeat contributors.
An increase in contributors becoming maintainers.
An increase in the amount of engaged community members in Slack.
An increase in the number of engaged community members authoring blog posts.
An increase in the number of engaged community members delivering talks.
An increase in the number of questions asked on StackOverflow.

Announcements/2018 05 03 System Reactive Has A New Home On Github

NoTitle: true
IsBlog: true
Title: System.Reactive has a new home on GitHub
Tags: Announcement
Author: Geoffrey Huntley
Published: 2018-05-03

At MVP Summit, the community met with Microsoft and with their support and encouragement the community forked control of System.Reactive. Over the last couple weeks some of the smartest brains from multiple ecosystems have united in our Slack instance to plan for the future.

One of the items that everyone agreed upon almost instantaneously was that reactive programming on dotnet needed to have a stronger branding/marketing presense. We need to signal that System.Reactive is part of .NET and that living under the existing Reactive-Extensions GitHub organization did not convey that message.

Today the community, in conjunction with Microsoft shipped the first milestone on our initial roadmap.

#Rx.NET is moving under https://t.co/4piNpJ5uOxHuge milestone, amazing achievementA huge round of applause for @onovotny and @GeoffreyHuntley— Emil Petro (@petroemil) May 3, 2018
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

This is big news because System.Reactive for .NET is the OG and original implementation of the Reactive Extensions. Sadly it's potential was artificially limited over the years while other ecosystems saw massive growth. It's time to put that narrative to bed though. It's time to move on. Thank you Jon Galloway, Phil Carter, Bart de Smet, Immo Landwerth for your help with advancing the community past this historical narrative.

[](https://github.com/dotnet/reactive)

Our new home under the .NET organization on GitHub provides better discoverability and visibility. It provides CI systems that keep up with the rapid evolution that's happening in .NET. The new location is closer to .NET development itself and components from System.Reactive which are logical base class library extensions now have shorter integration paths into corefxlabs. A great demonstration of this is how System.Reactive's (Ix) IAsyncEnumerable is graduating into a first-class citizen in C# v8.

It also means that the Reactive Extensions will now automatically show up in data exports of opensource activity on GitHub for Microsoft execs. This is a big deal as Microsoft is heavily driven by data. If the community shines bright, is open/inclusive, stays on track then the future is very very 🚀

This is a new era. Join the conversation over at ReactiveUI Slack and ask how you can help.

Announcements/2018 05 04 Delisting Of Versions Before 8 0 0 From Nuget

NoTitle: true
IsBlog: true
Title: Delisting of versions before 8.0.0 from NuGet
Tags: Announcement
Author: Geoffrey Huntley
Published: 2018-05-04

As part of the v8.0.0 release, ReactiveUI changed the field separator used in our package names from dashes to periods which is the standard convention used in dotnet. It was a breaking change, and our documentation was updated as part of the release to provide you with instructions of which package is needed for every platform.

We changed the field separator as it allowed the project to implement the new package identity verification feature that was shipped recently by the NuGet team. This feature has allowed the ReactiveUI maintainers to reserve the ReactiveUI.* namespace and prevent other people from publishing to it. It also provides a visual indicator in Visual Studio - the blue tick - that the package has been verified as coming from the ReactiveUI maintainers.

Unfortunately, there is no easy way for ReactiveUI to rename or alias existing packages or provide an easier migration path. We had had to unlist all of the packages before v8.0.0 because they were turning up in the NuGet gallery search and causing consumer confusion. Unlisting a package does NOT delete the package from NuGet.

If you have an existing project, then package restores will continue to function as is. If you need to scaffold up a project using an older version, then it will not appear in the search results, but you can install it by specifying the exact version.

We have created a table that lists out all of the possibilities and in the right-hand column of the table, you'll find the exact command that you can paste in the Package Manager console to install ReactiveUI.

If you experience problems, please open an issue on GitHub with feedback. If you are from the NuGet team, please start a conversation with the maintainers as we didn't want to do this. Maybe you could implement a solution for us? We lost a couple million on our download stats. :/

Package Name	Version	Installation Instructions
reactiveui

Announcements/2018 05 07 Dotnet Core 3 And Reactiveui

NoTitle: true
IsBlog: true
Title: .NET Core 3 and ReactiveUI
Tags: Announcement
Author: Geoffrey Huntley
Published: 2018-05-07

At Microsoft Build Live today, Microsoft shared a first look at their plans for .NET Core 3. The highlight of .NET Core 3 is support for Windows desktop applications, specifically Windows Forms, Windows Presentation Framework (WPF), and UWP XAML. Soon you will be able to run new and existing Windows desktop applications on .NET Core and enjoy all the benefits that .NET Core has to offer.

I’m extremely excited about us bringing WPF and WinForms to .NET Core. https://t.co/eZnljtanml— Immo Landwerth #msbuild (@terrajobst) May 7, 2018
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

ReactiveUI had some heads up what was coming and added netcoreapp20 as a supported platform as part of the release of v8.0.0 last week. When netcoreapp30 lands ReactiveUI fully intends to support these scenarios. It's unclear at this stage if it means that WPF/WinForms will be able to run on other platforms in the future - I seriously doubt it as it would be a massive undertaking but if Microsoft does it - ReactiveUI will support it.

If you need to ship cross-platform applications on .NET core right now, then the maintainers of ReactiveUI recommends that you check out Avalonia. Their community is as active, as vibrant as ours, open by default and you can drop in for a chat.

If you want to get a head start on .NET Core 3.0 and want to make it possible sooner - send in a PR that 🚢's this:

https://github.com/reactiveui/ReactiveUI/issues/1575

Announcements/2018 05 14 Reactiveui Succession

NoTitle: true
IsBlog: true
Title: ReactiveUI Succession
Tags: Announcement
Author: Rodney Littles, II
Published: 2018-05-14

OSS project maintainers have a serious load on their shoulders. They are responsible for authoring and maintaining tools that enable developers to deliver business value faster and easier. Gone are the days where a developer has to start every project by defining their own IO, data structures and sub routines. Modern developers rely on frameworks, third party libraries and other niceties that use to take hundreds of developer man hours before writing any business logic. Being a maintainer, and focusing that level of effort is a labour of love, but a labour not the less.

We as .NET developers shouldn't rely solely on Microsoft to provide tooling. We shouldn't be naive in thinking that the latest update to a NuGet package just magically materializes from the ethers. These things happen because our peers make them happen. They provide time, talent, and capacity. This is time they could be spending with their kids, learning to play guitar or preparing for the next 5K. Developers that consume these tools can change the narrative. We can get involved.

There are many levels of involvement. Creating Issues when we encounter odd experiences. Pull Requests if we happen to find and fix the root cause. Feedback on how easy the tools we use are to consume and integrate into our pipelines. Monetary to offset the "free" software your business is getting value from consuming.

There comes a time when a single point of failure in an application can bring down an entire system. This happens in OSS as well. The maintainers of ReactiveUI have done an amazing job putting together a library that allows for use of Functional Reactive paradigms. Now is the time to help alleviate a single point of failure and setup a scalable system to take ReactiveUI into the next era of Open Source Software.

We, the consumers of this library, need to find a way to pull together and maintain this library as a community. We need to establish a road map, identify new features, create a community stand up, delegate work so we can continue to react long after the current maintainers step away for some well deserved rest and relaxation.

We have to accept that if we don't contribute, ReactiveUI won't grow. That there may not be a fresh NuGet package when we need a bug fixed. There may not be not be a library when the next evolution of .NET comes out of Microsoft. I urge you to get involved. We don't want a tragedy of the commons. We want a healthy way to tame mutable state in the .NET eco system. ReactiveUI has been our tool this long, and we want to keep it healthy, stable and fresh for years to come.

I believe the community needs to take the following steps:

Establish a unified vision and product road map
Create teams to help delegate tasks
Organize our approach for delivering value
Preach our successes, and get people interested in ReactiveUI
Grow the community, and help each other learn

There has been a lot of conversation in the community around these topics over the last two weeks. We are planning an overhaul in the way we deliver ReactiveUI. These topics have been at the forefront of the ReactiveUI teams discussions and there will be some announcements over the next week explaining more. If you can't wait for these announcements because you've just got to know how you can get involved, join us on Slack ReactiveUI Slack and head into the #reactiveui-succession channel to find out how you can be part of these changes that will shape the future of ReactiveUI!

Announcements/2018 05 15 Memory Leak Detection

NoTitle: true
IsBlog: true
Title: Memory Leak Detection
Tags: Announcement
Author: Geoffrey Huntley
Published: 2018-05-15

Moments ago we merged a contribution by Grzegorz Kotfis that adds another layer of protection before the project moves towards automated continuous delivery. The pull-request added a new project called ReactiveUI.LeakTests which allows the maintainers to specify tests that can determine memory leaks by checking memory usage for objects of a particular type, or tests that track memory traffic and fail in case the traffic exceeds some threshold.

In other words, the ReactiveUI unit testing harness now includes a memory profiler. We are using the free dotMemory Unit by JetBrains. It sounds complicated, but it's not. dotMemory Unit works with almost all of the unit-testing frameworks on the market including our testing framework of choice xUnit.net.

csharp

[Test]
public void Observable_Subscription_IsDisposed()
{
    ... // do some work

    dotMemory.Check(memory =>
        Assert.That(memory.GetObjects(where => where.Type.Is<ReactiveObject>()).ObjectsCount, Is.EqualTo(0)));
}

Thank-you Grzegorz!

ps. We are currently looking for folks who are interested in performance work to aide with critically accessing the performance of ReactiveUI, the Reactive Extensions for .NET and System.Linq.Expressions.

Sound interesting? Jump in ReactiveUI Slack, introduce yourself and ask how you can help out.

Announcements/2018 08 13 Deprecated Reactive List

NoTitle: true
IsBlog: true
Title: Deprecating ReactiveList
Tags: Announcement
Author: Rodney Littles, II
Published: 2018-08-13

ReactiveUI is deprecating `ReactiveList`

With the coming 8.6.1 release, ReactiveList will be marked as deprecated. ReactiveList is being replaced by Roland Pheasants Dynamic Data

What does this mean for me?

We hope, nothing. Other than no longer supporting the public API of ReactiveList, the end user shouldn't experience any change. There will be some internal clean up of the code base that will be changed over to use Dynamic Data as opposed to Reactive Lists. There are several reasons why ReactiveUI has made this decision for the platform. These reasons have been outlined and can be discussed in further detail on the RFC or the GitHub Issue #1372.

Next steps

The work will begin in the next week to push a package with ReactiveList marked as deprecated. Shortly after that package is released, work will begin to move ReactiveUI towards Dynamic Data. ReactiveList isn't going away, we are just going to hide it from the public interface and put it in the legacy space.

Dynamic Data's creator Roland Pheasant has provided an Introduction for ReactiveUI Users as a starting point for ReactiveUI consumers.

If you're willing to test the pre-release version of this change, or you have concerns that this change will break your app join us over at ReactiveUI Slack, or comment on the RFC or Issue linked above.

Announcements/2018 08 28 Reactiveui Succession Update

NoTitle: true
IsBlog: true
Title: ReactiveUI Succession Update
Tags: Announcement
Author: Rodney Littles, II
Published: 2018-08-28

ReactiveUI has released several minor versions since 8.0. Some of the most recent versions have been released without Geoff having to push code, or prep issues. This is thanks to members of the core team, and community members who have stepped up to move the project forward. Glenn Watson has started to play a large role in the maintenance of ReactiveUI. There have been other's getting involved in enhancing some of the platform logic, and documentation. Community members have been identifying and resolving issues that help make our framework better. What does this mean for ReactiveUI succession? It's happening. What does that mean for you? It means we are working on ways to improve ReactiveUI and make it easier to consume. We have several initiatives on the team and there are a few RFC's planned for the 9.0 release that might be of interest.

We are trying to make the contributor experience better. RFC 18 is about enforcing a consistent coding style across the entire code base. We are going to configure analyzers that will enforce the Core Fx rules. This will remove the friction of contributors having to check to see if their changes are compliant with our rules before submitting a Pull Request! This change will also add xml comments to our public API surface. Going forward consumers of ReactiveUI will get intellisense comments for the public API inside the IDE.

Another, more significant change is RFC 10 which brings the deprecation of ReactiveList. We are removing ReactiveList in favor of Roland Pheasant's Dynamic Data. There have been numerous issues reported around ReactiveList, from performance concerns to usability of the feature. We felt that instead of continuing support our implementation, we should move towards an implementation that is reactive, and built to handle what ReactiveList was intended for, and more. You can read more about Dynamic Data for ReactiveUI Consumers

There have been a few work streams in the ReactiveUI repository to support this effort. We took deprecation of ReactiveList as an opportunity to incorporate performance benchmarks using Benchmark DotNet. Before changing the internals of ReactiveUI, we felt it best to verify any memory or performance concerns with this change. Our long term plan is to benchmark as many areas in the framework that make sense so we can look for the best ways to improve performance in the future.

ReactiveUI version 9.0 is coming and with it some improvements. We aren't done there, what will be the focus of ReactiveUI v10? What do you want to see included? Join us on Slack ReactiveUI Slack, or post an RFC and tell us what would improve your consumer experience!

Announcements/2018 11 07 Reactive Command Abstract

NoTitle: true
IsBlog: true
Title: Removing ReactiveCommand abstract base class
Tags: Announcement
Author: Rodney Littles, II
Published: 2018-11-07

The ReactiveUI team has been urging consumers for some time now to move away from the ReactiveCommand abstract class for properties. There are some slight nuiances with type constraints that can sometimes cause run time bugs. Because your property can resolve to an abstract base implementation doesn't mean you should define it that way. We are very adamante about creating a type safe environment where consumers don't have to worry about hidden runtime issues with the framework. RFC: Remove ReactiveCommand abstract base class was raised to address this exact issue.

ReactiveCommand LoginCommand = ReactiveCommand.Create(ExecuteLogin); works fine at compile time. Depending on the type resolution and what your expectation of the Create TParam and TReturn types, this doesn't work as expected. ReactiveUI bindings can also be affected by types not resolving correctly at run time. To close the loop on this, and make good on our feedback of "don't do that", we have removed the ReactiveCommand abstract base class. This will enforce our concerns for using ReactiveCommand<TParam, TResult> to ensure avoidance of runtime type resolution issues.

This change shouldn't cause any breaking changes to the ReactiveCommand, but if you have been using the abstract base class to define properties, moving to the new package, you will have to define the types of your existing commands. If you previously extended the ReactiveCommand abstract base class, you should change that to derive from ReactiveCommandBase<TParam, TResult> in the future.

Announcements/2019 01 20 Reactiveui Rebranding

NoTitle: true
IsBlog: true
Title: ReactiveUI Rebranding
Tags: Announcement
Author: Artyom Gorchakov
Published: 2019-01-20

ReactiveUI was created by Anaïs Betts whilst working in Office Labs at Microsoft, and released in early 2011. Since that time, ReactiveUI has become a mature framework trusted by Slack, GitHub, Amazon, Elastic and Microsoft, has become a member of the Dot Net Foundation, and actively maintained by the open-source community on GitHub. The work we do is sponsored by our wonderful Backers on Reactive Marbles.

Now, the Team focuses on improving developer accessibility of ReactiveUI. Numerous issues were fixed during the past year, missing xml documentation was added, exception messages were clarified. We are now at a level of maturity where chatlogs in the documentation pages aren't needed anymore. Most features of the framework are well-documented now, including testing, routing and activation. If you would like to learn ReactiveUI in-depth, step by step, consider purchasing the book "You, I and ReactiveUI" written by Kent Boogaart.

Another way of improving ReactiveUI is making the framework more attractive and recognizable. We are working now on updating the image of ReactiveUI documentation website, to follow modern design trends and to improve the user experience. We are pleased to show you the new ReactiveUI logo!

When developing it, we tried to make things as simple as possible, but still recognizable by developers who use ReactiveUI. The new logo is easier for printing, SVG and PSD files are available in our styleguide repository. Hope you love it, and more updates are yet to come, including design improvements of our website. Join our ReactiveUI Slack, if not already.

Announcements/2021 01 04 Reactiveui Association

NoTitle: true
IsBlog: true
Title: ReactiveUI Association, Inc.
Tags: Announcement
Author: Rodney Littles, II
Published: 2021-01-04
Order: 5

OSS Sustainability

Open Source Sustainability has become a big topic in the .NET community. With several Open Source projects having issues with long term sustainability, the ReactiveUI team has been identifying ways to address the long term sustainability of our open-source software. Our main goal is to make sure that as .NET grows and evolves that Reactive Programming and ReactiveUI evolve and grow with it. We have started to talk about strategies to ensure that ReactiveUI has maintenance and growth for the future.

ReactiveUI Association, Inc.

Introducing. ReactiveUI Association Inc. A non for profit organization geared towards several goals

Open Source Sustainability for ReactiveUI
Educational Resources for building applications using ReactiveUI

Reactive Programming Open Source Sustainability in the .NET ecosystem

The maintainers of ReactiveUI are also consumers of the framework. We strive to make sure that as .NET continues to grow, that ReactiveUI will be a safe long-term choice for building .NET native applications. We want to be sure that we continue to grow and mentor the community so that more members get involved. We already have a very healthy user community. Developers who take time to log issues, provide reproductions, and pull request fixes. This is a good sign that this project is capable of long term health.

Providing Educational Resources on building .NET applications using Reactive Programming

We have been making a conscious effort to make the framework more approachable. We have started recording videos and bolstering documentation in the hopes it makes it easier to consume ReactiveUI. We recently had our first ever RxUI Conf, which was spurred on to help with this very endeavor. Educating people on how to consume Rx in the .NET space is the only way to grow the Rx community in the .NET space. So we are committing time and resources towards making these learnings available.

Securing sponsorships

The reality is things code money. So we are trying to find ways to engage with more consumers as a way to cover the costs of the goals of the ReactiveUI Association. Now that we have our legal entity, the appeal of Open Collective is dwindling. With new services like GitHub Sponsorships, we will move towards a platform that allows consumers, sponsors, and friends to contribute monetarily to the ReactiveUI Association and its mission. The original purpose of the Open Collective was to allocate money towards a resource to maintain the library. We no longer feel that is the immediate goal, so we plan on closing the open collective. This will allow the governance of the fund to exist within the ReactiveUI Associate towards its mission and goals. If you are currently sponsoring the Open Collective, we ask that you consider changing to become a GitHub Sponsor until we can sort out the current Open Collective.

Whats next

Setting up ReactiveUI Association GitHub Sponsorship

In the coming months, we will be moving over to the GitHub Sponsorship platform. This will allow a consistent mechanism for any Open Source project you want to sponsor via GitHub. This will be a change for anyone currently using the Open Collective. We are working to set up a self-sufficient association that can manage the funds without the need for Open Collective. Now that we are our Non-Profit organization, we can manage the funds directly. This will allow us to put more of the funds we have to use towards the betterment of the ReactiveUI project.

Focus on learnings

We realize that the barrier to entry to Rx is high. The ReactiveUI Association's primary focus is fostering learning. The core team have been putting together a series of videos on various aspects of ReactiveUI. We are posting periodic videos to the ReactiveUI YouTube channel. We hosted our first ever RxUI Conf that is available on our YouTube Channel. We plan on doing more things focused on helping people experience and enjoy the power of Reactive Programming.

Reactive Marbles is the incubator for future ReactiveUI work

The ReactiveUI Association has a new GitHub organization, Reactive Marbles this will be the incubator for new things coming to the ReactiveUI platform. Currently, we have new WhenAnyValue methods, code analyzers and fixers, and more coming soon! Same guys, different name, same mission!

Announcements/Index

hide:
- toc

Announcements

Articles/2013 02 27 Reactiveui V4.4.2 Released

NoTitle: true
IsBlog: true
Title: ReactiveUI v4.4.2 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2013-02-27

[What's New](https://github.com/reactiveui/reactiveui/compare/4.4.1...4.4.2)

Improve speed of View lookup, get rid of spurious throwing
Add documentation for RxUI View Bindings
Fix several WinRT-only bugs, especially around the SuspensionHost scenario

Articles/2013 03 05 Reactiveui V4.4.3 Released

NoTitle: true
IsBlog: true
Title: ReactiveUI v4.4.3 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2013-03-05

[What's New](https://github.com/reactiveui/reactiveui/compare/4.4.2...4.4.3)

Fix a bug with certain service locators on WP7 (#197)
Fix a bug related to sorting in CreateDerivedCollection (#195)
Allow the connection created in CreateDerivedCollection to be disconnected (#199)
Enable Type Conversion and Binding Hooks in BindTo and correct a crashing bug in WinRT (#201)

Articles/2013 03 12 Reactiveui V4.5.0 Released

NoTitle: true
IsBlog: true
Title: ReactiveUI v4.5.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2013-03-12

[What's New](https://github.com/reactiveui/reactiveui/compare/4.4.3...4.5.0)

Xamarin.iOS and Xamarin.Mac support

This release brings initial support for the latest Xamarin.Mac and Xamarin.iOS. Using ReactiveUI and Xamarin Studio, you can write cross-platform ViewModels and Model classes and bind them to Views using the same RxUI 4.x binding syntax.

ReactiveUI knows how to bind to Cocoa objects using Key-Value Observing
DeferredScheduler automatically runs code on the Cocoa main runloop
Routing and ViewModelViewHost is supported via a class that attaches to NSView
Command binding understands Cocoa controls via Cocoa target/action framework, including automatically disabling the control when CanExecute is false
Many common controls have implicit binding support

Experimental Xamarin.Android support

This release also includes very basic Xamarin.Android support, including a scheduler that will run code on the Activity's main thread.

What do I need to run this??

You need to run Xamarin Studio and make sure to have the latest updates installed from the Alpha Channel.

What else is New?

Bug fixes in UserError Handling
Extra documentation (thanks @ArturPhilibin!)
Add Debugger support for ReactiveCollection (#204, thanks @distantcam!)

Articles/2013 06 19 Reactiveui V4.6.4 Released

NoTitle: true
IsBlog: true
Title: ReactiveUI v4.6.4 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2013-06-19

[What's New](https://github.com/reactiveui/reactiveui/compare/4.5.0...4.6.4)

Notable Changes Since 4.5.0

Improved support for ReactiveUI on iOS and Android, including Suspension Manager support
A UINavigationController for iOS that participates in ViewModel-based view location
OrderedComparer, a new way to write IComparable implementations using a LINQ'ish syntax
Make ReactiveDerivedCollection read-only and fix notification bugs
We now generate Symbol packages for ReactiveUI
Fixes for BindCommand on WinRT, where EventArgs don't actually have to be derived from System.EventArgs
ReactiveAsyncAction now signals completion
Fixes bug where WP8 projects would incorrectly be flagged as running in the test runner

Articles/2013 07 03 Reactiveui V5.0.1 Released

NoTitle: true
IsBlog: true
Title: ReactiveUI v5.0.1 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2013-07-03

After 3 months, 427 commits by 12 different contributors, and 689 total files changed, the stable release of ReactiveUI 5.0 is now live! A huge thanks to the contributors for this release:

Markus Olsson
Johan Laanstra
Oliver Weichhold
Phil Haack
Christopher Atkins
Brad Phelan
Georg Rollinger
Kent Boogaart
Wenda Zhou

[Check out the Ship PR](https://github.com/reactiveui/ReactiveUI/pull/219)

Here's the release highlights:

ReactiveUI is now totally Portable-Friendly

ReactiveUI now is compatible with .NET 4.5 Portable Libraries, you can now write cross-platform ViewModels but still use almost all of the RxUI features.

Unfortunately, to do this, we had to drop support for a number of older platforms. If you are using Silverlight, WP7, or .NET 4.0, you'll have to stick with ReactiveUI 4.x, which will still be maintained in a separate branch.

ReactiveUI 5.x has full support for the following platforms:

Xamarin.iOS
Xamarin.Android
Xamarin.Mac
.NET 4.5 (WPF)
Windows Phone 8
Windows Store Apps (WinRT)

ReactiveUI.Events

ReactiveUI now makes it easy to bind to UI events, without having to use Observable.FromEventPattern. Many UI controls and other objects now have an Events() extension method. For example:

``` cs
theButton.Events().Clicked.Subscribe(x => / ... /);

text

This makes it far cleaner to compose complex UI interactions at the view level.

## A much improved API surface

This release is the "Clean up" breaking changes release - many deprecated methods have been removed - I'm proud to say that this release removes over 2x the number of lines that it adds, and only leaves what Should Be There. 

Many names have been changed to be more clear, methods have been removed or clarified, and in general, ReactiveUI 5.0 is a more pleasant framework to use. However, this means that moving from RxUI 4.x to 5.x can be a bit of work. Check out [the migration guide](https://github.com/reactiveui/ReactiveUI/blob/main/docs/migrating-from-rxui4.md) for more information. 

## Testable Initialization

ReactiveUI now has much more straightforward initialization - you can initialize ReactiveUI yourself in a test runner, ensure that tests won't register over other tests, and there is a new Service Locator implementation that is much more flexible with regard to object lifetimes than the old built-in service locator. RxApp itself now has much less in it, relying instead on the new `RxApp.DependencyResolver` property.

---

### Articles/2013 10 12 Reactiveui V5.2.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v5.2.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2013-10-12
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/5.1.2...5.2.0)

### iOS Improvements

This release adds Reactive versions of a number of common UIKit classes, such as UIImageView. RxUI also now comes with a new class for UITableViewSource, `ReactiveTableViewSource`. This class will wrap a `ReactiveList<ViewModel>` class and automatically animate in and out cells from the table view as they change (PR #377)

### Android improvements

This release adds basic binding support for common Android controls, thanks to #371. Thanks @oliverw!

### Combined Commands

`ReactiveCommand` now supports combining commands, so it's easy to create a command that invokes one or more "child" commands, check out #382 for more information.

### Modern Xamarin support

ReactiveUI is now built against the official Xamarin Rx binaries. This means that on MonoMac, you need to be up-to-date on the latest Mono install. 

### Bug Fixes
- Fixes to ViewLocator to be more helpful if registration isn't set up (#359, thanks @terenced!)
- Move RxUI.Mobile interfaces to the portable library so you can use them from PLibs (#364)
- Perf improvement when looking up interfaces (#366, thanks @2asoft!)
- Fixes to Auto Data Template (#367, thanks @chrisway!)
- Fix to AutoPersist (#383, thanks @vevix!)
- Updates to handle the latest Rx Microsoft release 
- Make sure ReactiveCommand's `IsExecuting` always comes back on the UI thread (#373)

---

### Articles/2013 11 21 Reactiveui V5.3.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v5.3.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2013-11-21
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/5.2.0...5.3.0)

### Improved iOS Table View / Collection View support

Thanks to @meteficha and @alanpog, ReactiveUI's support for UITableView and UICollectionView is now vastly improved. We now support:
- Custom Section Headers and Footers
- Support for UICollectionView via new ReactiveCollectionViewSource class, similar to ReactiveTableViewSource
- Support for adding / removing sections dynamically in a Reactive way, via the `Data` property on ReactiveTableViewSource
- Added several new IViewFor-friendly Cocoa view subclasses, such as ReactiveCollectionViewCell
- You can now easily detect when the table has finished updating to avoid making changes during a table reshuffle, via `DidPerformUpdates`

### ViewModelViewHost and RoutedViewHost for WinForms

Thanks to @rikbosch, ReactiveUI.WinForms now has support for both RoutedViewHost and ViewModelViewHost, so you can create IViewFor-based Controls. (#396) 

### Bug Fixes
- Make FuncDependencyResolver handle `GetService` correctly via returning the last item (#389), thanks @journeyman!
- Fix a race condition in ObservableAsyncMRUCache, thanks @npnelson!
- Create an overload of ObservableForProperty that's a bit more F# friendly, thanks @marklam!
- Code cleanups to our project files (#387), thanks @pH-minamo!

---

### Articles/2013 12 14 Reactiveui V5.4.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v5.4.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2013-12-14
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/5.3.0...5.4.0)

Since some of these fixes change behavior (such as the NLog fix), this is a minor release - however, most of these changes _shouldn't_ affect existing programs

### Bug Fixes
- Allow binding to 3rd party control libraries in WinForms (#405, thanks @rikbosch)
- Fix F# friendly ObservableForProperty (#407, thanks @marklam)
- Clean up NuSpec files for Xamarin on Visual Studio (#410, thanks @onovotny)
- Fixes to deserializing ReactiveObjects using certain serializers (#412, thanks @meteficha)
- Small improvements to derived collections (#417, thanks @meteficha)
- Change NLog to use the full class name so it is easier to filter on (thanks @npnelson)
- Race condition and reentrancy fixes to Reactive(Table/Collection)ViewSource (#425 + #426 + #433, thanks @meteficha)
- Remove Pex from the list of test runners because it conflicts with WriteableBitmapEx (#428, thanks @tiagomargalho)
- Fix up some of the collection interfaces (#430, thanks @Haacked)
- Add Count\* observables to list interfaces (#436, thanks @onovotny)
- Disable setting up ViewHosts in design mode

---

### Articles/2013 12 25 Reactiveui V6.0.0 Preview 1 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.0 Preview 1 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2013-12-25
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/main...5.99.0)

This is a prerelease version of ReactiveUI 6.0 - use at your own release, we make no guarantees that this works for you or even at all.

### [Check the Ship PR](https://github.com/reactiveui/ReactiveUI/pull/434) for more info

---

### Articles/2014 01 30 Reactiveui V6.0.0 Preview 4 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.0 Preview 4 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-01-30
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/main...5.99.0)

This is a prerelease version of ReactiveUI 6.0 - use at your own release, we make no guarantees that this works for you or even at all.

### [Check the Ship PR](https://github.com/reactiveui/ReactiveUI/pull/434) for more info

---

### Articles/2014 03 03 Reactiveui V5.5.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v5.5.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-03-03
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/5.4.0...5.5.0)

## Bug Fixes
- Command bindings in WinForms now affect Enabled (#443, thanks @rzhw)
- Ensure that common WinForms controls don't get trumped by WPF (#447, thanks @rzhw)
- Enable BindCommand to work with nested ViewModels (#450, thanks @onovotny!)
- Attempt to prevent the Mono linker from stripping things we need (#455, thanks @onovotny!)
- Improvements to iOS binding (#473, #496, thanks @tberman)

## Activation

Thanks to the great work by @jen20, the View / ViewModel activation from ReactiveUI 6.0 has been backported to 5.x. Normally large features aren't backported, but due to discovering that DependencyProperties leak memory in bindings without this feature, we decided to backport it. 

### What do you mean, leaks?

The following code, in a sane world, wouldn't leak:

``` cs
public MyCoolUserControl()
{
    this.OneWayBind(ViewModel, x => x.FirstName, x => x.FirstName.Text);
}

Normally, when both the View and the ViewModel go out of scope, the GC would clean them both up and everything would be great. However, because of the Dependency Property system, this isn't true. Every time you WhenAny or Bind through a DependencyProperty, you must explicitly clean it up by Disposing. To help out with this, a new method has been created on Views and ViewModels.

Consider the following ViewModel constructor:

``` cs
public MyBrokenViewModel()
{
UserError.RegisterHandler(x => {
// NB: Stuff
});
}

text

This is broken because every time we create MyBrokenViewModel, we create another error handler. What Do? What we really want for certain global things like UserError, is for UserError to be subscribed only when the View associated with the ViewModel is _visible_. However, that information isn't available to ViewModels, and even if it was, it's not super obvious. Let's fix it

### How does this work:

Activation allows you, for both Views and ViewModels, to set up _the things that should be_ **active** _when the View is visible_. Here's how you do it for ViewModels:

``` cs
public class MyWorkingViewModel : ReactiveObject, ISupportsActivation
{
    public ViewModelActivator Activator { get; protected set; }

    public ActivatingViewModel()
    {
        Activator = this.WhenActivated(d => {
            // d() registers a Disposable to be cleaned up when
            // the View is deactivated / removed
            d(UserError.RegisterHandler(x => {
                // NB: Stuff
            }));
        });
    }
}

Here's how it works for Views:

``` cs
public class MyWorkingView : UserControl, IViewFor<MyWorkingViewModel>
{
public ActivatingView()
{
this.WhenActivated(d => {
Console.WriteLine("Helloooooo Nurse!")
d(Disposable.Create(() => Console.WriteLine("Goodbye, Cruel World")));
});
}
}

text

Note that calling `WhenActivated` in a View automatically means that the associated ViewModel gets notified for activated / deactivated changes (and in fact, you _must_ call `WhenActivated` in the View to get the ViewModel to be notified).

---

### Articles/2014 03 29 Reactiveui V6.0.0 Preview 6 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.0 Preview 6 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-03-29
---


## [What's New](https://github.com/reactiveui/ReactiveUI/compare/5.99.4...5.99.5)

This is a prerelease version of ReactiveUI 6.0 - use at your own release, we make no guarantees that this works for you or even at all.

### [Check the Ship PR](https://github.com/reactiveui/ReactiveUI/pull/434) for more info

---

### Articles/2014 04 10 Reactiveui V5.5.1 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v5.5.1 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-04-10
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/5.5.0...5.5.1)
- Fix a glitch in XAML-based apps where WhenAny'ing DependencyProperties sometimes wouldn't work (Backport of #558)
- Bump the version of Rx on MonoMac to the one currently shipping in Mono

---

### Articles/2014 05 31 Reactiveui V6.0.0 Preview 7 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.0 Preview 7 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-05-31
---


## [What's New](https://github.com/reactiveui/ReactiveUI/compare/5.99.5...5.99.6)

This is a prerelease version of ReactiveUI 6.0 - use at your own release, we make no guarantees that this works for you or even at all.

### [Check the Ship PR](https://github.com/reactiveui/ReactiveUI/pull/434) for more info

---

### Articles/2014 07 09 Reactiveui V6.0.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-07-09
---

## Welcome to ReactiveUI 6.0

After 8 months of work, 878 commits, and 1032 files changed, ReactiveUI 6.0 is finally released, the biggest RxUI release ever! A huge thanks to our contributers for this release:
- Johan Laanstra
- Oren Novotny
- Todd Berman
- Michael Teper
- Felipe Lessa
- Amy Palamountain
- Dennis Daume
- Rik Bosch
- James Nugent
- Phil Haack
- Maratoss
- David Lechner
- Justin Manus
- Keith Dahlby
- Markus Olsson

In particular, a huge thanks goes to Johan, who has done an enormous amount of great work on this release. Thank you so much!

## Migrating from existing code

We've written [a migration guide](https://github.com/reactiveui/ReactiveUI/blob/main/docs/migrating-from-rxui5.md) to help existing application authors migrate their 5.x applications to ReactiveUI 6.0. Check out this document before updating your dependencies to get a heads-up as to what you're in for.

## What's New in ReactiveUI 6.0

Over 120 new features were merged into ReactiveUI 6.0, trying to sum them all up is a huge undertaking! Here are some of the highlights:

### Universal Windows Phone app and Xamarin Forms Support

ReactiveUI 6.0 has great support for all of the latest developer platforms, including WinRT Universal Apps as well as support for the new Xamarin Forms UI toolkit via the new `ReactiveUI-XamForms` NuGet package. Use either the updated Portable Library support, or use the new Shared Projects tooling in Visual Studio.

Existing support for Android and iOS has also been greatly improved, including support for unit test runners on those platforms, as well as creating Observable abstractions for all events via the `ReactiveUI-Events` package. Helpers for the Android Support Library are now also provided, via the `ReactiveUI-AndroidSupport` package.

ReactiveUI 6.0 supports the following platforms (In order of personal developer joy):
- Xamarin.Android
- Xamarin.iOS
- Xamarin.Mac
- Xamarin Forms (iOS + Android + WP8)
- .NET 4.5 (WPF and Windows Forms, via `ReactiveUI-WinForms`)
- Universal Windows Apps (WPA81)
- Windows Phone 8.0 Apps (Silverlight-based)
- Windows Store Apps (WinRT)

### ReactiveUI makes creating list-based views a snap

We've added great support for recycling list-based views on iOS and Android (`UICollectionView` and `UITableView` on iOS, `ListAdapter` on Android). These new adapter classes allow you to map a ReactiveList of ViewModel objects and automatically create and recycle the associated views, for high-performance lists without writing a ton of boilerplate code.

On iOS, added and removed items will even be automatically animated in and out. On Android, we help you easily implement the ViewHolder pattern to limit the amount of work done while scrolling.

### Large Application Performance

One of the focuses of this release has been performance and memory usage in large applications. ReactiveUI 6.0 is much less prone to creating memory leaks in application code via WeakEventManager, as well as more performant by eliminating scheduling latency as much as possible. Other features, such as View and ViewModel Activation, allow you to create and clean-up objects only when the View is actually visible on-screen, saving a lot of unnecessary work.

While some of these changes will require you to update your application and unit tests, the end result is an application that uses less memory and feels more responsive.

### The same Rx, Everywhere

ReactiveUI 5.x used a separate installation of the Reactive Extensions for .NET for Xamarin projects, which made creating proper Portable Libraries more difficult. RxUI 6.0 now resolves this completely, and you can now build ViewModels that work on every supported platform.

## Questions, Comments, Concerns?

There are three great venues for problems / questions related to this release:
- [The ReactiveUI mailing list](https://groups.google.com/group/reactivexaml)
- [Issues on GitHub](https://github.com/reactiveui/ReactiveUI/issues)
- The ReactiveUI Slack chat room - if you're interested in joining this chat room, please Email [email protected] from the Email you want to use and I can add you.

---

### Articles/2014 07 17 Reactiveui V6.0.1 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.1 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-07-17
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.0.0...6.0.1)

### Bug Fixes
- Update Xamarin Forms to have correct metadata (#662, thanks @nestalk)
- Fix issue with Android platform on startup (#659)
- Fix design-time issue on WPF with RoutedViewHost
- Fix issue with bindings disappearing on WPF (#672, thanks @jlaanstra)
- Update Android Support Library to v20

---

### Articles/2014 07 25 Reactiveui V6.0.2 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.2 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-07-25
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.0.1...6.0.2)

#### Bug Fixes
- Improvements to iOS collection views (#678, #681, thanks @tberman)
- Fix exception in WeakEventHandler when adding an element twice (#679, thanks @jlaanstra)
- Update to Rx 2.2.5 to support Universal PCL Profile259 (#676, thanks @jlaanstra)

---

### Articles/2014 08 03 Reactiveui V6.0.3 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.3 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-08-03
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.0.2...6.0.3)

### Bug Fixes
- Fixed an issue where subscribing to `Changed` could cause weird crashes (#665, thanks @sickboy + @mteper)
- Fix a bug where ReactiveCommand wouldn't correctly marshal exceptions (#686, thanks @flagbug)
- Don't leak an event to `IsHitTestVisible` when using `WhenActivated` (#689, thanks @jlaanstra)

---

### Articles/2014 08 19 Reactiveui V6.0.4 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.4 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-08-19
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.0.3...6.0.4)

### Bug Fixes
- Fix SupportLib NuGet package (#692, thanks @shiftkey)
- Fix bug in WhenActivated where deactivation wouldn't run (#690, thanks @jlaanstra)
- Ensure SetItem fires the correct notification (#693, thanks @TheGrandUser)
- Fix activation on NSWindowController (#696, thanks @mteper)
- Use ExecuteAsync in InvokeCommand (#700, #701, thanks @jlaanstra + @timmit93)
- Ensure ToProperty properties fire Changing notification (#703)
- Don't set the Scheduler in Xamarin.Forms in the test runner. 
- Link Xamarin.Mac to NuGet Rx binaries instead of ones shipped in the framework, since Mono no longer ships them.

---

### Articles/2014 08 20 Reactiveui V6.0.5 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.5 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-08-20
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.0.4...6.0.5)

### ToProperty and ReactiveCommand are no longer lazy in a test runner

In certain situations, tests that appear to be reasonable would fail, due to a View not being bound to the ViewModel under test. This is due to an optimization that was added in the RxUI 6.0 era, where subscriptions would not be created until the value was requested for the first time. 

While the behavior is correct, it also resulted in tricky-to-debug test failures. Now, in the unit test runner, we disable this feature and eagerly subscribe to the source. Check out #705 for more information.

### Bug Fixes
- ReactiveUI is now built using the Xamarin Stable branch, which means that RxUI-Events for iOS is now based on iOS 7.x instead of being based on the iOS 8 Beta
- Fixed typo in error message (#704, thanks @mteper)

---

### Articles/2014 08 26 Reactiveui V6.0.6 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.6 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-08-26
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.0.5...6.0.6)
- Enable activation for NSViewControllers via hacky hax (#706, thanks @mteper)

---

### Articles/2014 09 17 Reactiveui V6.0.7 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.0.7 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-09-17
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.0.6...6.0.7)

## Android Scheduler improvements

On Android, an improved Scheduler based on RxJava is now automatically configured in your application, that no longer requires setup in OnCreate. Using the main thread scheduler should now work even in contexts such as bound services or other non-Activity scenarios. (#717). 

This PR also fixes an issue where scheduling from non-UI threads in Xamarin Forms-based apps could incorrectly throw an exception. 

## Documentation Galore

This release marks the first release whose source code contains our first steps toward comprehensive documentation. This has been a multiple-month effort from several people, such as @rikbosch, @niik, @dchaib, and @npnelson. Documentation will now be stored [in the documentation folder](../documentation/index.md) and will be kept up-to-date as components change.

Right now while many of the docs are stubs, the "basics" folder is completely written, it's highly recommended to check out the documents in this folder for more information.

## WinForms Improvements

ReactiveUI now supports controls which derive from Component, such as ToolStripButton. Thanks to @vanderkleij for the patches (#720, #721)

## Other
- Add a Reactive class for UITabBarController (#723, thanks @tberman)
- Allow Commands to be used with Menu Items (#722, thanks @mteper)
- IsExecuting is now false as soon as the result from ExecuteAsync returns if awaited. (#714, thanks @Haacked)

---

### Articles/2014 10 03 Reactiveui V6.1.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.1.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-10-03
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.0.7...6.1.0)

### ViewModel-based Routing for Xamarin.Forms Apps (#724)

Several small fixes have come together to enable ReactiveUI ViewModel-based Routing and auto-serialization for Xamarin.Forms-based apps:



See [the PR for a sample app](https://github.com/reactiveui/ReactiveUI/pull/724), and check out the [documentation on Routing](../documentation/handbook/routing.md) for more information on how it works.

### Other Fixes
- Added a version of `TestScheduler.With` that is async/await aware
- Added a SupportLib version of ReactiveFragment

---

### Articles/2014 11 11 Reactiveui V6.2.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.2.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-11-11
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.1.0...6.2.0)

### Xamarin.iOS 64-bit support (#747)

ReactiveUI now fully supports the new 64-bit Xamarin.iOS API, if you are running Xamarin.iOS 8.4 or higher (currently in the Beta channel).

### Small Fixes
- Derived collections now have an `onRemove` method that can be used to clean up objects that are removed from the collection (#744, thanks @TheGrandUser)
- Remove opportunistic scheduling in Cocoa because of ordering issues (#745, thanks @tberman)
- Fix crashes where section changes could crash the app on iOS (#749, thanks @srimoyee-factory)
- Fix a crash when using `x => x` as your selector (#741, thanks @eggapauli)
- Propagate WhenActivated to subviews on iOS (#735, thanks @justin-factory)
- Fix issue where `INotifyPropertyChanging` was not defined on all platforms

---

### Articles/2014 11 23 Reactiveui V6.2.1 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.2.1 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2014-11-23
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.2.0...6.2.1)

Bug Fixes:
- Fix crash in Reactive[Table/Collection]DataSource (#755, thanks @srimoyee-factory)
- Fix an issue where Xamarin Forms routing would crash on startup #761 
- Fix issue around using `Changed` directly (#757, thanks @robhorvath)

---

### Articles/2015 01 04 Reactiveui V6.3.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.3.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2015-01-04
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.2.1...6.3.0)
- Support for Xamarin.iOS 8.6 - you **must** build based on this for Xamarin.iOS
- Add a Reactive FragmentActivity (#773, thanks @michaelstonis!)

---

### Articles/2015 01 13 Reactiveui V6.3.1 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.4.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2015-01-13
---

## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.3.0...6.3.1)

### Bug Fixes
- Xamarin.Forms is now compatible with 64-bit iOS (#790)
- Fix a crash in TestScheduler.WithAsync (#772, thanks @flagbug)
- Add ReactiveNavigationController (#783, thanks @BrianSakhai)

---

### Articles/2015 02 09 Reactiveui V6.4.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.4.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2015-02-09
---



## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.3.1...6.4.0)

### Xamarin.Mac 64-bit Support (#797)

Thanks to @mteper, ReactiveUI now has 64-bit Xamarin.Mac support

### Other Stuff
- Update constructors for Xamarin.iOS (#791, thanks @nverinaud)
- Create a ReactiveActionBarActivity class (#794, thanks @marcosbozza)

---

### Articles/2015 05 11 Reactiveui V6.5.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.5.0 released
Tags: Release Notes
Author: Anaïs Betts
Published: 2015-05-11
---



## [What's New](https://github.com/reactiveui/ReactiveUI/compare/6.4.0.1...6.5.0)

### Collection View improvements (#820)

Thanks to @kentcb, our support of UITableViewController and UICollectionViewController are **much** more reliable, and will correctly animate in items. A huge thanks for an awesome PR!



### Dependency version bumps

This version of ReactiveUI requires Xamarin.Forms 1.4.2 and the latest Xamarin.Android AppCompat library. This most likely won't be a problem, but if it is you can downgrade to 6.4.x. 

### Bug fixes
- Fix issue where WhenAnyObservable doesn't protect against null (#831, thanks @kentcb)
- Improve WeakEventHandler when working with Xamarin.Forms, prevent crash (#826, thanks @nsainaney)
- Allow null property name to be used with WhenAny (#811, thanks @asarium)
- Improve binding error logging (#840, thanks @bradtwurst)
- Add constructors to ReactiveActivity and ReactiveFragment to allow them to inherit a Java reference (#841, thanks @jonfuller)
- Fix Xamarin.Forms navigation with ViewModel-first navigation (#819, thanks @bratsche)
- Cleanup to activation on WP (#825, thanks @flagbug)

---

### Articles/2016 08 17 Reactiveui V6.5.1 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.5.1 released
Tags: Release Notes
Author: Geoffrey Huntley
Published: 2016-08-17
---



This release resolves a NuGet metadata defect which was preventing the installation of ReactiveUI into portable class libraries that targeted `Profile259`. The assemblies within v6.5.1 are the same as those found in v6.5.0.

For new projects, we recommend joining us in Slack and using the v7 nightlies which are available from MyGet as we are in the final stages of preparing for the release of v7.0.0.

---

### Articles/2016 09 04 Reactiveui V6.5.2 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v6.5.2 released
Tags: Release Notes
Author: Geoffrey Huntley
Published: 2016-09-04
---



This release resolves a NuGet metadata defect which was preventing the installation of ReactiveUI into Windows Phone projects (issue https://github.com/reactiveui/ReactiveUI/issues/1146). The assemblies within v6.5.2 are the same as those found in v6.5.1 and v6.5.0. 

For new projects, we recommend joining us in Slack and using the v7 nightlies which are available from MyGet as we are in the final stages of preparing for the release of v7.0.0.

---

### Articles/2016 11 12 Reactiveui V7.0.0 Released

---
NoTitle: true
IsBlog: true
Title: ReactiveUI v7.0.0 released
Tags: Release Notes
Author: Geoffrey Huntley
Published: 2016-11-12
---

_Oh, hai!_



Wow! It's been a while, but we have a juicy new release for you. We had to take some time to heal internally, to train and mentor the future generations of maintainers which are going to carry us forward.  Additionally the .NET ecosystem changed underneath us, and we didn't have continuous integration setup. Let this be a lesson to anyone considering operating an open-source project that targets nine platforms. Have a roadmap and succession plan in place and never allow long-running branches, ever. Implement continuous integration and mature your release processes to the point where cutting a new release is as simple as pressing a button.

**So what is ReactiveUI?**

ReactiveUI is inspired by functional reactive programming and is the father of the ReactiveCocoa (Cocoa/Swift) framework. Internally we debate whether we are or are not a framework, as at its core the project is essentially a bunch of extension methods for the Reactive Extensions.

ReactiveUI was started seven years ago and is now old enough to attend grade school but unlike a teenager is extremely stable. ReactiveUI has matured over the years into a solid and fine choice for building your next application. Additionally, because the implementation is unopinionated migration from another framework to ReactiveUI is incredibly easy.. You can slide it in on a single ViewModel and then migrate as you become more comfortable. Avoid those costly rewrites.

When reading the code, you'll find that ReactiveUI is rather unopinionated in the implementation, but we have always held some beliefs which have been the basis and foundation of the project.

We believe that code is communication between people, that also happens to run on a computer. If you optimise for humans, then over a long time your project will end up better. Software should be understandable by other people; that is super important. 

We believe that only the power of the Reactive Extensions allows you to express the idea around a feature in one readable place. 



Think about your typical user interface? It's a mutable bag of sadness with code all over the place. Instead of telling a computer how to do its job, why not define what the computers job is and get out of its way? If that sounds odd, let us re-introduce you to Microsoft Excel. 

Instead of doing the typical ViewModel isLoading = true/false mutable dance by toggling it on and off in different branches of your code. Why not express the condition in a single place using a Microsoft Excel expression - =SUM(A1: B2)?

**Still not convinced?**
- [Why You Should Be Building Better Mobile Apps with Reactive Programming](https://www.youtube.com/watch?v=DYEbUF4xs1Q) – Michael Stonis (Xamarin Univeristy Trainer/Eightbot)
- [Awaiting for Rx: A Play in Four Acts](https://www.youtube.com/watch?v=5DZ8nC0ENdg) - Anaïs Betts (Slack/GitHub) 
- [FRP In Practice: Taking a look at ReactiveUI/ReactiveCocoa](https://www.youtube.com/watch?v=1XNATGjqM6U) by Anaïs Betts (Slack/GitHub)

Maybe you need to watch this insanely smart, and eccentric guy in a tie-dye t-shirt do maths on a whiteboard:

[](https://channel9.msdn.com/Shows/Going+Deep/E2E-Erik-Meijer-and-Wes-Dyer-Reactive-Framework-Rx-Under-the-Hood-1-of-2)

Async/await is the zombie plague. Liberate your codebase today.

ReactiveUI is used in production at GitHub, Slack, Microsoft and is supported by consultants from different companies from all around the world. It's used at our clients, we can't name names specifically, but we encourage our community to [showcase where and how they have used ReactiveUI in their applications](https://github.com/reactiveui/ReactiveUI/issues/979), some members have even gone [as far as open-sourcing their app and sharing their entire codebase](https://github.com/github/VisualStudio/tree/master/src). You are of course under no obligation to share these insights (or code) with us but it is greatly appreciated by the project maintainers, and you'll usually get a retweet out of it.

**Where are the examples?**

We are working on it; this release was for us. Next release is for you.  For now:
- Read https://docs.reactiveui.net/en/fundamentals/history.html
- [Watch the guest lecture over at Xamarin Univeristy](https://university.xamarin.com/guestlectures/introduction-to-reactiveui-for-xamarin)
- [Watch this god damn amazing video series by Kent Boogaart (one of the core maintainers)](https://github.com/kentcb/WorkoutWotch)
- [Play with the Xamarin University lecture source code. (Xamarin Forms)](https://github.com/TheEightBot/Reactive-Examples)
- [Play with the GitHub for Windows Visual Studio source code. (WPF)](https://github.com/github/visualstudio)

**Rx is hard**

No, it's not. Learning Rx is one of the best things you can do to improve yourself as a software engineer. Unit testing was hard, so was dependency injection at first. The principals you learn during your journey will forever change you and best of all the knowledge is implementation and language agnostic. We have designed ReactiveUI so you can slowly transition from an async/await codebase at a pace that feels comfortable to you.



## Highlights

## ReactiveCommand is Better

`ReactiveCommand` is completely rewritten again (sorry).
- interfaces are gone. Any use of `IReactiveCommand` should be replaced with `ReactiveCommand`, possibly with type information (see below).
- static creation methods have changed:
  - execution logic is _always_ required when calling `CreateXxx` methods, including synchronous commands (i.e. those created with `Create`). So rather than calling `Create` and then subscribing, you call `Create` and pass in your execution logic right then and there.
  - for consistency, the execution logic is always provided as the first parameter. Other parameters (`canExecute`, `scheduler`) are optional.
  - `CreateAsyncObservable` is now called `CreateFromObservable`.
  - `CreateAsyncTask` is now called `CreateFromTask`.
- parameter types are formalized by `TParam` in `ReactiveCommand<TParam, TResult>`.
  - if your command takes a parameter, you no longer take an `object` and cast it. Instead, you explicitly specify the parameter type when creating the command (of course, you can still choose `object` as your `TParam` if that makes sense, perhaps as an intermediary migration step).
- `ICommand` is now implemented explicitly. As a result:
  - the `Execute` exposed by `ReactiveCommand` is reactive (it returns `IObservable`). It is therefore lazy and won't do anything unless something subscribes to it.
  - `CanExecuteObservable` is now called `CanExecute`.
- observables such as `CanExecute` and `IsExecuting` are now behavioral. That is, they will always provide the current value to new subscribers.
- `RoutingState` has been updated to use the new implementation. Consequently, any use of its commands will be affected per the above.
- the `ToCommand` extension method has been removed. This was a simple convenience to take an `IObservable` and use it as the `canExecute` pipeline for a new command. If you're using `ToCommand`, you can just replace it with a call to one of the creation methods on `ReactiveCommand`.

**Old:**

``` cs
var canExecute = ...;
var someCommand = ReactiveCommand.Create(canExecute);
someCommand.Subscribe(x => /* execution logic */);

var someAsyncCommand1 = ReactiveCommand.CreateAsyncObservable(canExecute, someObservableMethod);
var someAsyncCommand2 = ReactiveCommand.CreateAsyncTask(canExecute, someTaskMethod);

someCommand.Execute();

New:

``` cs
var canExecute = ...;
var someCommand = ReactiveCommand.Create(() => / execution logic /);

var someAsyncCommand1 = ReactiveCommand.CreateFromObservable(someObservableMethod, canExecute);
var someAsyncCommand2 = ReactiveCommand.CreateFromTask(someTaskMethod, canExecute);

someCommand.Execute().Subscribe();
```

For more details, please see the extensive documentation on this topic.

Note To enable you to ease into the migration, all previous types are available under the ReactiveUI.Legacy namespace. Note, however, that there is no legacy version of RoutingState, so any code you have that interacts with its command may require minor updates.

Interactions are New and Exciting

UserError has been generalized and re-imagined. We call it interactions, and we think you'll like it. We did this in part because people were feeling icky using UserError for non-error scenarios. Basically, we realized that people need a general mechanism via which a view model can ask a question, and wait for the answer. It doesn't have to be an error - we're not that pessimistic! You could be asking to confirm a file deletion, or maybe how the weather is out there in the analog world.

Migrating from UserError to the interactions infrastructure is not really a case of one-for-one substitution. But here are some tips to get you started:

read through the documentation first.
decide whether you need shared interactions and, if so, define them in an appropriate place for your application (often just a static class).
for any non-shared interactions, have your view model create an instance of the interaction and expose it via a property.
typically you want the corresponding view to handle interactions by calling one of the RegisterHandler methods on the interaction exposed by the view model.
the view model can call Handle on the interaction, passing in an input value.
Recovery commands are no longer a built-in thing. If you need such a mechanism for your interactions, you are encouraged to write an appropriate class and use it as the input for your interaction.

Note To enable you to ease into the migration, all previous types are available under the ReactiveUI.Legacy namespace.

ToProperty is now eager by default

In previous ReactiveUI versions, ToProperty was lazy. That is, it would have no effect unless something was "pulling" on the target property. This was for performance reasons, as you may have properties that are expensive to resolve, but only used in specific scenarios.

Whilst this was good for performance, it was often confusing and contrary to expectations. Therefore, ToProperty is no longer lazy - it immediately subscribes to ensure the property's value reflects the given observable pipeline. However, the original lazy behavior can be obtained by passing in true to the deferSubscription parameter.

Automation galore

A mountain of effort has gone into automating ReactiveUI's build and deployment infrastructure (thanks @ghuntley!). Using tools such as Cake, AppVeyor, and gitversion, we now have a very compelling automation story. This is no mean feat, especially considering the vast array of platforms on which ReactiveUI runs, and must therefore be built.

The end goal here is to get you, the community, new versions of ReactiveUI more rapidly and seamlessly.

Details

As part of this release we had 113 issues closed.

All Platforms

#1189 Add WhenAnyObservable overloads that combine latest via a given selector
#1161 Remove BindCommand implementation taking Func<TParam>
#1158 Throw UnhandledErrorException when a thrown exception goes unhandled (rather than just Exception)
#1157 Fix InvokeCommand to respect the command's execution window
#1091 Add WhenActivated overload that takes a CompositeDisposable, as well as a DisposeWith extension method
#971 #1035 #1054 #1085 #1088 Overhaul reactive commands
#1084 Enhance ToProperty to work with indexers
#1082 Add scheduling support to RoutingState
#1079 Add Activated and Deactivated observables to ViewModelActivator
#1061 ToProperty is no longer lazy by default
#964 #1055 #1181 Add interactions feature
#1052 Add Bind overloads that convert via Funcs
#1028 Improve CreateCollection overloads
#1021 Generalize auto-persistence helpers to work against IReactiveCollection<T>
#1018 BindTo now throws a helpful exception when attempting to bind to null
#1015 Enhance the default view locator to resolve views when the VM is abstracted as an interface
#1013 Add auto-registration feature for views within a given assembly
#1012 Add scheduler parameter to CreateCollection
#977 Add WhenNavigatedToObservable method, telling you whenever a given view model is on top of the navigation stack
#962 Fix a race condition in ObservableAsPropertyHelper
#938 Don't automatically create a DataTemplate if the DisplayMemberPath of an ItemsControl is set
#936 Ensure ObservableAsPropertyHelper provides the initial value immediately
#926 Remove potentially expensive hash calculation from ReactiveList
#914 Remove ViewContractAttribute
#913 Remove fallbackValue from binding methods
#875 Relax generic constraints on ToProperty from ReactiveObject to IReactiveObject
#943 Add ReactiveUserControl to relevant XAML platforms
#935 Add XmlnsDefinitionAttribute for those XAML platforms that support it
#879 Add ViewContract property to ViewModelViewHost for XAML platforms
#1149 Set nuspec dependency to == (exact) version as that is being built
#1142 Fix Splat dependency
#1110 Fix WaitForScheduler exception handling

Events Generator

#1151 reactiveui-events now targets UWP 10.0.14393.0 (aka anniversary edition)
#1056 eventbuilder.exe is now xplat and always uses the latest SDK's
#1187 Ignore CS[1591,0618,0105,0672] because that code is generated

Windows Phone, Store and Universal

#1192 Fixed ReactiveUI to install into a library targeting WPA81 (Profile111)
#1174 Retired Windows Phone Silverlight
#1099 Changed LaunchActivatedEventArgs to IActivatedEventArgs
#1045 Add Universal Windows Platform (UWP) support
#940 Update platform UAP 10069 -> UWP 10240, add Events and Testing projects

Xamarin Android

#1186 Android timepicker now uses Hour/Minute instead of CurrentHour/CurrentMinute
#1144 Small bug fixes to ReactiveRecyclerViewAdapter and ViewHolder
#1105 Add ReactiveAppCompatActivity
#1095 Add AsObservable when ISubject is returned as IObservable
#1067 Add Android reactive preferences
#1059 Add Rx implementation of the Android shared preferences changed
#1058 Add Rx implementation of the Android USB permission request
#1057 Add Rx implementation of the Android service bind
#1044 Resolve an issue building android support project
#985 Add serializer.Serialize(st, state); into SaveState
#982 Add a basic reactive adapter for the Android RecyclerView
#939 Add a reactive version of the Android.Support.V4.DialogFragment class
#885 Add a ControlFetcherMixin for the Android Support library

Xamarin Forms

#1160 Use non-generic BindableProperty.Create, since the generic overloads are deprecated
#952 #1115 Add support for view activation
#942 #1074 #1071 #986 Lots of routing fixes and improvements
#1032 Add reactive pages
#921 Add reactive cells
#953 Upgrade Xamarin Forms dependency
#951 Throw a useful exception from ViewModelViewHost if the view is of the wrong type
#950 Use ContentView as base class for ViewModelViewHost
#919 Fix ViewModelViewHost bug where collection is modified whilst being enumerated
#861 Retarget ReactiveUI.Xamforms to Profile259
#1153 Update reactiveui-xamforms nuspec dependency from v2.1.0.6529 to v2.3.1.114
#1152 Upgrade reactiveui-core for Xamarin.Forms from v2.2.0.31 to v2.3.1.114
#1150 Upgrade reactiveui-events for Xamarin.Forms from v2.2.0.31 to v2.3.1.114
#1196 Resolve a crash when using ViewModelViewHost with Xamarin Forms

Xamarin iOS

#1182 Use ViewWillAppear for iOS activation (not ViewDidAppear)
#1176 Migrate reactiveui-testing from Monotouch to Xamarin.iOS
#1087 Make ReactiveNavigationController activatable
#1086 Fix various RoutedViewHost issues
#927 Rewrite CommonReactiveSource to be reactive and fix numerous bugs
#917 Add ReactiveSplitViewController
#874 Make iOS ViewModelViewHost an actual view controller
#873 Fix a CommonReactiveSource race condition by ensuring that batched changes result in BeginUpdates call ASAP
#1177 Fix code generation of events with iOS 10

Xamarin Mac

#1185 Use Xamarin.Mac framework for reactiveui/reactiveui-testing/microsoft-reactive-testing
#1175 Xamarin.Mac (unified) now compiles on windows
#1022 Add ViewAttributes to Xamarin.Mac projects
#916 Fix ViewModelViewHost on Mac
#887 Changed output to Xamarin.Mac20 to reflect reality and added .nuspec

Housekeeping

#1188 Upload .dll artefacts to AppVeyor on successful build
#1179 Run unit tests as part of continuous integration pipeline
#1178 Resolved an issue with continuous integration pipeline
#1148 Bootstrapper now downloads/installs Android API level 24
#1140 Add GitHub issue/PR templates
#1128 Enable strict mode (fail the build on any powershell error)
#1092 Continuous integration and pre-release builds for v7
#1010 Compiler warnings for events disabled to reduce CI log spam

Documentation

#1003 Initial revamp of README.md
#898 Update compelling example in README.md for v6.x

Where to get it

You can download this release from nuget.org

Articles/2017 01 12 Reactiveui V7.1.0 Released

NoTitle: true
IsBlog: true
Title: ReactiveUI v7.1.0 released
Tags: Release Notes
Author: Geoffrey Huntley
Published: 2017-01-12

As part of this release we had 8 commits which resulted in 4 issues being closed.

All Platforms

#1225 fix: reactiveui NuGet packages should be pinned and only work with packages from the same release
#1218 fix: subscription leakage in ReactiveCommand

Xamarin Android

#1217 feature: allow WireUpControls to find View members

Xamarin iOS

#1216 feature: added generic reactive controllers and views for iOS and Mac

Xamarin Mac

#1216 feature: added generic reactive controllers and views for iOS and Mac

Where to get it

You can download this release from nuget.org

Articles/2017 05 04 Reactiveui V7.3.0 Released

NoTitle: true
IsBlog: true
Title: ReactiveUI v7.3.0 released
Tags: Release Notes
Author: Geoffrey Huntley
Published: 2017-05-04

As part of this release we had 17 commits which resulted in 17 issues being closed.

__All Platforms__

__#1325__ fix: schedule output of ReactiveCommand.Execute
__#1317__ refactor: removed unused extension method and make class internal
__#1306__ refactor: use xunit IsType in unit tests

__Xamarin Android__

__#1302__ feature: improved exception message when there are multiple resource IDs with the same name

__Xamarin Mac__

__#1259__ bug: the assembly for Xamarin.Mac20 in the reactiveui-events NuGet package was not included

__Housekeeping__

__#1331__ housekeeping: use [email protected] for all communication
__#1313__ housekeeping: add table of contents with relative links
__#1326__ housekeeping: add backers and sponsors from Open Collective

__Documentation__

__#1323__ chore: tidy up ReactiveCollectionMixin xml comments
__#1322__ chore: tidy up xml comments in PropertyBinding
__#1321__ chore: tidy up xml comments in OrderedComparer
__#1320__ chore: improved ObservedChangedMixin xml documentation
__#1319__ chore: tidy up XMLDOC in ObservableAsPropertyHelper
__#1310__ chore: tidy xml documentation for AutoPersistHelpers
__#1308__ chore: tidy xml comments in RegisterableInterfaces
__#1307__ chore: tidy up xml comment
__#1309__ chore: fix xml doc referencing type with generic arguments

Where to get it

You can download this release from nuget.org

Announcements/Tags/Announcement Copy Section

Posts tagged "Announcement"

Announcements/2017 08 25 Automatic Closure Of Stale Github Issues Copy Section

Announcements/2017 09 05 Assemblies Are Now Code Signed With The Dotnet Foundation Certificate Copy Section

Announcements/2017 09 07 The Public Api Surface Of Reactiveui Is Now Protected By Approval Tests Copy Section

Announcements/2017 09 13 Run A Meetup Are You Looking For Presenters Copy Section

Announcements/2018 04 22 You I And Reactiveui Copy Section

Announcements/2018 04 30 The Future Of System Reactive Copy Section

Announcements/2018 05 02 Moving Towards Vsts And Continuous Deployment Copy Section

Announcements/2018 05 03 System Reactive Has A New Home On Github Copy Section

Announcements/2018 05 04 Delisting Of Versions Before 8 0 0 From Nuget Copy Section

Announcements/2018 05 07 Dotnet Core 3 And Reactiveui Copy Section

Announcements/2018 05 14 Reactiveui Succession Copy Section

Announcements/2018 05 15 Memory Leak Detection Copy Section

Announcements/2018 08 13 Deprecated Reactive List Copy Section

ReactiveUI is deprecating `ReactiveList` Copy Chapter

What does this mean for me? Copy Chapter

Next steps Copy Chapter

Announcements/2018 08 28 Reactiveui Succession Update Copy Section

Announcements/2018 11 07 Reactive Command Abstract Copy Section

Announcements/2019 01 20 Reactiveui Rebranding Copy Section

Announcements/2021 01 04 Reactiveui Association Copy Section

OSS Sustainability Copy Chapter

ReactiveUI Association, Inc. Copy Chapter

Reactive Programming Open Source Sustainability in the .NET ecosystem Copy Section

Providing Educational Resources on building .NET applications using Reactive Programming Copy Section

Securing sponsorships Copy Section

Whats next Copy Chapter

Setting up ReactiveUI Association GitHub Sponsorship Copy Section

Focus on learnings Copy Section

Reactive Marbles is the incubator for future ReactiveUI work Copy Section

Announcements/Index Copy Section

Announcements

Articles/2013 02 27 Reactiveui V4.4.2 Released Copy Section

[What's New](https://github.com/reactiveui/reactiveui/compare/4.4.1...4.4.2) Copy Chapter

Articles/2013 03 05 Reactiveui V4.4.3 Released Copy Section

[What's New](https://github.com/reactiveui/reactiveui/compare/4.4.2...4.4.3) Copy Chapter

Articles/2013 03 12 Reactiveui V4.5.0 Released Copy Section

[What's New](https://github.com/reactiveui/reactiveui/compare/4.4.3...4.5.0) Copy Chapter

Xamarin.iOS and Xamarin.Mac support Copy Chapter

Experimental Xamarin.Android support Copy Chapter

What do I need to run this?? Copy Chapter

What else is New? Copy Chapter

Articles/2013 06 19 Reactiveui V4.6.4 Released Copy Section

[What's New](https://github.com/reactiveui/reactiveui/compare/4.5.0...4.6.4) Copy Chapter

Notable Changes Since 4.5.0 Copy Chapter

Articles/2013 07 03 Reactiveui V5.0.1 Released Copy Section

[Check out the Ship PR](https://github.com/reactiveui/ReactiveUI/pull/219) Copy Chapter

ReactiveUI is now totally Portable-Friendly Copy Chapter

ReactiveUI.Events Copy Chapter

Interactions are New and Exciting Copy Chapter

ToProperty is now eager by default Copy Chapter

Automation galore Copy Chapter

Details Copy Chapter

Where to get it Copy Section

Articles/2017 01 12 Reactiveui V7.1.0 Released Copy Section

Where to get it Copy Section

Articles/2017 05 04 Reactiveui V7.3.0 Released Copy Section

Where to get it Copy Section

Explore Related Technologies & Topics

Announcements/Tags/Announcement

Announcements/2017 08 25 Automatic Closure Of Stale Github Issues

Announcements/2017 09 05 Assemblies Are Now Code Signed With The Dotnet Foundation Certificate

Announcements/2017 09 07 The Public Api Surface Of Reactiveui Is Now Protected By Approval Tests

Announcements/2017 09 13 Run A Meetup Are You Looking For Presenters

Announcements/2018 04 22 You I And Reactiveui

Announcements/2018 04 30 The Future Of System Reactive

Announcements/2018 05 02 Moving Towards Vsts And Continuous Deployment

Announcements/2018 05 03 System Reactive Has A New Home On Github

Announcements/2018 05 04 Delisting Of Versions Before 8 0 0 From Nuget

Announcements/2018 05 07 Dotnet Core 3 And Reactiveui

Announcements/2018 05 14 Reactiveui Succession

Announcements/2018 05 15 Memory Leak Detection

Announcements/2018 08 13 Deprecated Reactive List

ReactiveUI is deprecating `ReactiveList`

What does this mean for me?

Next steps

Announcements/2018 08 28 Reactiveui Succession Update

Announcements/2018 11 07 Reactive Command Abstract

Announcements/2019 01 20 Reactiveui Rebranding

Announcements/2021 01 04 Reactiveui Association

OSS Sustainability

ReactiveUI Association, Inc.

Reactive Programming Open Source Sustainability in the .NET ecosystem

Providing Educational Resources on building .NET applications using Reactive Programming

Securing sponsorships

Whats next

Setting up ReactiveUI Association GitHub Sponsorship

Focus on learnings

Reactive Marbles is the incubator for future ReactiveUI work

Announcements/Index

Articles/2013 02 27 Reactiveui V4.4.2 Released

[What's New](https://github.com/reactiveui/reactiveui/compare/4.4.1...4.4.2)

Articles/2013 03 05 Reactiveui V4.4.3 Released

[What's New](https://github.com/reactiveui/reactiveui/compare/4.4.2...4.4.3)

Articles/2013 03 12 Reactiveui V4.5.0 Released

[What's New](https://github.com/reactiveui/reactiveui/compare/4.4.3...4.5.0)

Xamarin.iOS and Xamarin.Mac support

Experimental Xamarin.Android support

What do I need to run this??

What else is New?

Articles/2013 06 19 Reactiveui V4.6.4 Released

[What's New](https://github.com/reactiveui/reactiveui/compare/4.5.0...4.6.4)

Notable Changes Since 4.5.0

Articles/2013 07 03 Reactiveui V5.0.1 Released

[Check out the Ship PR](https://github.com/reactiveui/ReactiveUI/pull/219)

ReactiveUI is now totally Portable-Friendly

ReactiveUI.Events

Interactions are New and Exciting

ToProperty is now eager by default

Automation galore

Details

Where to get it

Articles/2017 01 12 Reactiveui V7.1.0 Released

Where to get it

Articles/2017 05 04 Reactiveui V7.3.0 Released

Where to get it