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 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](https://github.com/reactiveui/ReactiveUI/issues/979#issuecomment-196735701), has become a member of the [Dot Net Foundation](https://www.dotnetfoundation.org/), and actively maintained by the open-source community on GitHub. The work we do is sponsored by [our wonderful Backers on Reactive Marbles](https://github.com/sponsors/reactivemarbles).
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](https://github.com/reactiveui/rfcs/issues/19) was raised to address this exact issue.
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.
With the coming 8.6.1 release, `ReactiveList` will be marked as deprecated. ReactiveList is being replaced by Roland Pheasants [Dynamic Data](https://github.com/reactivemarbles/DynamicData)
Moments ago we merged [a contribution](https://github.com/reactiveui/ReactiveUI/pull/1527) by [Grzegorz Kotfis](https://twitter.com/gkotfis) that adds another layer of protection before the project moves towards [automated continuous delivery](https://reactiveui.net/blog/2018/05/moving-towards-vsts-and-continuous-deployment). 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.
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.
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](https://reactiveui.net/docs/getting-started/installation/nuget-packages/) for every platform.
At MVP Summit, [the community met with Microsoft](https://github.com/Reactive-Extensions/Rx.NET/issues/466#issuecomment-370496523) 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](https://join.slack.com/t/reactivex/shared_invite/zt-lt48skpz-G5WDYOAuzA80_MByZrLT0g) to plan for the future.
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](https://www.dotnetfoundation.org/blog/2016/06/16/rx-net-welcome).
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/](https://kent-boogaart.com/you-i-and-reactiveui/).
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.
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](../documentation/security/index.md) 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.
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](https://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](https://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](../contribute/index.md) 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](../documentation/security/index.md) 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](https://github.com/reactiveui/ReactiveUI/pull/1463). 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](https://github.com/Particular/NServiceBus/blame/develop/src/NServiceBus.Core.Tests/API/APIApprovals.ApproveNServiceBus.approved.txt).
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.
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/](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](https://www.dotnetfoundation.org/blog/2016/06/16/rx-net-welcome).
At MVP Summit, [the community met with Bart](https://github.com/Reactive-Extensions/Rx.NET/issues/466#issuecomment-370496523) 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](https://vimeo.com/132192255) - 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](https://channel9.msdn.com/Events/TechEd/Australia/Tech-Ed-Australia-2011/ARC-MID206) is [built](https://github.com/AdaptiveConsulting/ReactiveTrader) upon [this technology](https://github.com/RolandPheasant/DynamicData). They use ReactiveUI + System.Reactive to [build their desktop applications](https://github.com/RolandPheasant/TailBlazer). Customers use System.Reactive as their [backbone for their event processing backends](https://medium.com/netflix-techblog/reactive-programming-at-netflix-b944d49874d2). 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](https://twitter.com/GeoffreyHuntley/status/986163246724861952) and here's what we think the next steps should be:
- [Finish the pull-request that merges assemblies and ship System.Reactive 4.0.](https://github.com/Reactive-Extensions/Rx.NET/pull/418)
- [Move the GitHub repository to exist under dotnet/reactive](https://github.com/Reactive-Extensions/Rx.NET/issues/466)
- [Add approval tests to the public API surface](https://github.com/Reactive-Extensions/Rx.NET/issues/479)
- [Increase test coverage and amount of platforms used as validated against by the continuous integration.](https://github.com/Reactive-Extensions/Rx.NET/issues/478)
- Review outstanding [issues](https://github.com/Reactive-Extensions/Rx.NET/issues) and [pull-requests](https://github.com/Reactive-Extensions/Rx.NET/pulls).
- [Solicit help from the community, the creators of these techniques and the innovators/maintainers from other ecosystems to help define the future and help make it happen](https://twitter.com/GeoffreyHuntley/status/986163246724861952).
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](https://join.slack.com/t/reactivex/shared_invite/zt-lt48skpz-G5WDYOAuzA80_MByZrLT0g) in #rxnet and please consider [financially supporting the community](https://github.com/sponsors/reactivemarbles) 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](https://github.com/reactiveui/ReactiveUI/pull/1605) 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](https://github.com/Reactive-Extensions/Rx.NET/issues/466#issuecomment-370496523) 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](https://join.slack.com/t/reactivex/shared_invite/zt-lt48skpz-G5WDYOAuzA80_MByZrLT0g) 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](https://reactiveui.net/blog/2018/04/the-future-of-system-reactive).
I’m extremely excited about us bringing WPF and WinForms to .NET Core. https://t.co/eZnljtanml
— Immo Landwerth #msbuild (@terrajobst) May 7, 2018
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](../articles/2018-05-01-reactiveui-v8.0.0-released.md). 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](https://github.com/AvaloniaUI/Avalonia). Their community is as active, as vibrant as ours, open by default and [you can drop in for a chat](https://gitter.im/AvaloniaUI/Avalonia).
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](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](https://www.youtube.com/watch?v=0t85TyH-h04). 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](https://www.wired.com/2014/04/heartbleedslesson/). 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](https://github.com/papers-we-love/papers-we-love/blob/master/design/out-of-the-tar-pit.pdf). 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](https://www.youtube.com/watch?v=VS6IpvTWwkQ). 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](https://join.slack.com/t/reactivex/shared_invite/zt-lt48skpz-G5WDYOAuzA80_MByZrLT0g) 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](https://github.com/reactiveui/ReactiveUI/pull/1527) by [Grzegorz Kotfis](https://twitter.com/gkotfis) that adds another layer of protection before the project moves towards [automated continuous delivery](https://reactiveui.net/blog/2018/05/moving-towards-vsts-and-continuous-deployment). 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](https://www.jetbrains.com/help/dotmemory-unit/Introduction.html). 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](https://xunit.github.io/).
```csharp
[Test]
public void Observable_Subscription_IsDisposed()
{
... // do some work
dotMemory.Check(memory =>
Assert.That(memory.GetObjects(where => where.Type.Is()).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](2018-05-03-system-reactive-has-a-new-home-on-github.md) and [System.Linq.Expressions](https://github.com/bartdesmet/ExpressionFutures).
Sound interesting? Jump in [ReactiveUI Slack](https://join.slack.com/t/reactivex/shared_invite/zt-lt48skpz-G5WDYOAuzA80_MByZrLT0g), 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](https://github.com/reactivemarbles/DynamicData)
## 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](https://github.com/reactiveui/rfcs/issues/10) or the [GitHub Issue #1372](https://github.com/reactiveui/ReactiveUI/issues/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](https://github.com/reactivemarbles/DynamicData/wiki/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](https://join.slack.com/t/reactivex/shared_invite/zt-lt48skpz-G5WDYOAuzA80_MByZrLT0g), 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](https://github.com/reactiveui/rfcs/issues/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](https://github.com/dotnet/corefx/blob/master/Documentation/coding-guidelines/coding-style.md#c-coding-style) 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](https://github.com/reactiveui/rfcs/issues/10) which brings the deprecation of `ReactiveList`. We are removing `ReactiveList` in favor of [Roland Pheasant's Dynamic Data](https://github.com/reactivemarbles/DynamicData). 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](https://github.com/reactivemarbles/DynamicData/wiki/Introduction-for-ReactiveUI-users)
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](https://github.com/dotnet/BenchmarkDotNet). 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](https://join.slack.com/t/reactivex/shared_invite/zt-lt48skpz-G5WDYOAuzA80_MByZrLT0g), 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](https://github.com/reactiveui/rfcs/issues/19) 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` 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` 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](https://github.com/reactiveui/ReactiveUI/issues/979#issuecomment-196735701), has become a member of the [Dot Net Foundation](https://www.dotnetfoundation.org/), and actively maintained by the open-source community on GitHub. The work we do is sponsored by [our wonderful Backers on Reactive Marbles](https://github.com/sponsors/reactivemarbles).
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](../documentation/handbook/testing.md), [routing](../documentation/handbook/routing.md) and [activation](../documentation/handbook/when-activated.md). If you would like to learn ReactiveUI in-depth, step by step, consider purchasing the book ["You, I and ReactiveUI"](https://kent-boogaart.com/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](https://github.com/reactiveui/styleguide/). Hope you love it, and more updates are yet to come, including design improvements of our website. Join our [ReactiveUI Slack](https://join.slack.com/t/reactivex/shared_invite/zt-lt48skpz-G5WDYOAuzA80_MByZrLT0g), 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](https://github.com/sponsors/reactivemarbles) 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](https://www.youtube.com/channel/UCWVSpLajyZcooAngLV3ItaQ) channel. We hosted our first ever [RxUI Conf](https://www.rxuiconf.net/) 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](https://github.com/reactivemarbles) 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
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 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](https://github.com/reactiveui/ReactiveUI/issues/979#issuecomment-196735701), has become a member of the [Dot Net Foundation](https://www.dotnetfoundation.org/), and actively maintained by the open-source community on GitHub. The work we do is sponsored by [our wonderful Backers on Reactive Marbles](https://github.com/sponsors/reactivemarbles).
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](https://github.com/reactiveui/rfcs/issues/19) was raised to address this exact issue.
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.
With the coming 8.6.1 release, `ReactiveList` will be marked as deprecated. ReactiveList is being replaced by Roland Pheasants [Dynamic Data](https://github.com/reactivemarbles/DynamicData)
Moments ago we merged [a contribution](https://github.com/reactiveui/ReactiveUI/pull/1527) by [Grzegorz Kotfis](https://twitter.com/gkotfis) that adds another layer of protection before the project moves towards [automated continuous delivery](https://reactiveui.net/blog/2018/05/moving-towards-vsts-and-continuous-deployment). 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.
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.
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](https://reactiveui.net/docs/getting-started/installation/nuget-packages/) for every platform.
At MVP Summit, [the community met with Microsoft](https://github.com/Reactive-Extensions/Rx.NET/issues/466#issuecomment-370496523) 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](https://join.slack.com/t/reactivex/shared_invite/zt-lt48skpz-G5WDYOAuzA80_MByZrLT0g) to plan for the future.
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](https://www.dotnetfoundation.org/blog/2016/06/16/rx-net-welcome).
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/](https://kent-boogaart.com/you-i-and-reactiveui/).
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.
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](../documentation/security/index.md) 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.
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](https://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
---
### 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](https://xamarin.com/) 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 => /* ... */);
```
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` 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
});
}
```
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
{
public ActivatingView()
{
this.WhenActivated(d => {
Console.WriteLine("Helloooooo Nurse!")
d(Disposable.Create(() => Console.WriteLine("Goodbye, Cruel World")));
});
}
}
```
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 anais@anaisbetts.org 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`.
- 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](../documentation/handbook/commands/index.md) 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](../documentation/handbook/interactions/index.md) 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](https://github.com/reactiveui/ReactiveUI/issues?milestone=2&state=closed) closed.
**All Platforms**
- [**#1189**](https://github.com/reactiveui/ReactiveUI/pull/1189) Add `WhenAnyObservable` overloads that combine latest via a given selector
- [**#1161**](https://github.com/reactiveui/ReactiveUI/pull/1161) Remove `BindCommand` implementation taking `Func`
- [**#1158**](https://github.com/reactiveui/ReactiveUI/pull/1158) Throw `UnhandledErrorException` when a thrown exception goes unhandled (rather than just `Exception`)
- [**#1157**](https://github.com/reactiveui/ReactiveUI/pull/1157) Fix `InvokeCommand` to respect the command's execution window
- [**#1091**](https://github.com/reactiveui/ReactiveUI/pull/1091) Add `WhenActivated` overload that takes a `CompositeDisposable`, as well as a `DisposeWith` extension method
- [**#971**](https://github.com/reactiveui/ReactiveUI/pull/971) [**#1035**](https://github.com/reactiveui/ReactiveUI/pull/1035) [**#1054**](https://github.com/reactiveui/ReactiveUI/pull/1054) [**#1085**](https://github.com/reactiveui/ReactiveUI/pull/1085) [**#1088**](https://github.com/reactiveui/ReactiveUI/pull/1088) Overhaul reactive commands
- [**#1084**](https://github.com/reactiveui/ReactiveUI/pull/1084) Enhance `ToProperty` to work with indexers
- [**#1082**](https://github.com/reactiveui/ReactiveUI/pull/1082) Add scheduling support to `RoutingState`
- [**#1079**](https://github.com/reactiveui/ReactiveUI/pull/1079) Add `Activated` and `Deactivated` observables to `ViewModelActivator`
- [**#1061**](https://github.com/reactiveui/ReactiveUI/pull/1061) `ToProperty` is no longer lazy by default
- [**#964**](https://github.com/reactiveui/ReactiveUI/pull/964) [**#1055**](https://github.com/reactiveui/ReactiveUI/pull/1055) [**#1181**](https://github.com/reactiveui/ReactiveUI/pull/1181) Add interactions feature
- [**#1052**](https://github.com/reactiveui/ReactiveUI/pull/1052) Add `Bind` overloads that convert via `Func`s
- [**#1028**](https://github.com/reactiveui/ReactiveUI/pull/1028) Improve `CreateCollection` overloads
- [**#1021**](https://github.com/reactiveui/ReactiveUI/pull/1021) Generalize auto-persistence helpers to work against `IReactiveCollection`
- [**#1018**](https://github.com/reactiveui/ReactiveUI/pull/1018) `BindTo` now throws a helpful exception when attempting to bind to `null`
- [**#1015**](https://github.com/reactiveui/ReactiveUI/pull/1015) Enhance the default view locator to resolve views when the VM is abstracted as an interface
- [**#1013**](https://github.com/reactiveui/ReactiveUI/pull/1013) Add auto-registration feature for views within a given assembly
- [**#1012**](https://github.com/reactiveui/ReactiveUI/pull/1012) Add scheduler parameter to `CreateCollection`
- [**#977**](https://github.com/reactiveui/ReactiveUI/pull/977) Add `WhenNavigatedToObservable` method, telling you whenever a given view model is on top of the navigation stack
- [**#962**](https://github.com/reactiveui/ReactiveUI/pull/962) Fix a race condition in `ObservableAsPropertyHelper`
- [**#938**](https://github.com/reactiveui/ReactiveUI/pull/938) Don't automatically create a `DataTemplate` if the `DisplayMemberPath` of an `ItemsControl` is set
- [**#936**](https://github.com/reactiveui/ReactiveUI/pull/936) Ensure `ObservableAsPropertyHelper` provides the initial value immediately
- [**#926**](https://github.com/reactiveui/ReactiveUI/pull/926) Remove potentially expensive hash calculation from `ReactiveList`
- [**#914**](https://github.com/reactiveui/ReactiveUI/pull/914) Remove `ViewContractAttribute`
- [**#913**](https://github.com/reactiveui/ReactiveUI/pull/913) Remove `fallbackValue` from binding methods
- [**#875**](https://github.com/reactiveui/ReactiveUI/pull/875) Relax generic constraints on `ToProperty` from `ReactiveObject` to `IReactiveObject`
- [**#943**](https://github.com/reactiveui/ReactiveUI/pull/943) Add `ReactiveUserControl` to relevant XAML platforms
- [**#935**](https://github.com/reactiveui/ReactiveUI/pull/935) Add `XmlnsDefinitionAttribute` for those XAML platforms that support it
- [**#879**](https://github.com/reactiveui/ReactiveUI/pull/879) Add `ViewContract` property to `ViewModelViewHost` for XAML platforms
- [**#1149**](https://github.com/reactiveui/ReactiveUI/pull/1149) Set nuspec dependency to == (exact) version as that is being built
- [**#1142**](https://github.com/reactiveui/ReactiveUI/pull/1142) Fix Splat dependency
- [**#1110**](https://github.com/reactiveui/ReactiveUI/pull/1110) Fix `WaitForScheduler` exception handling
**Events Generator**
- [**#1151**](https://github.com/reactiveui/ReactiveUI/pull/1151) reactiveui-events now targets UWP 10.0.14393.0 (aka anniversary edition)
- [**#1056**](https://github.com/reactiveui/ReactiveUI/pull/1056) eventbuilder.exe is now xplat and always uses the latest SDK's
- [**#1187**](https://github.com/reactiveui/ReactiveUI/pull/1187) Ignore CS[1591,0618,0105,0672] because that code is generated
**Windows Phone, Store and Universal**
- [**#1192**](https://github.com/reactiveui/ReactiveUI/pull/1192) Fixed ReactiveUI to install into a library targeting WPA81 (Profile111)
- [**#1174**](https://github.com/reactiveui/ReactiveUI/pull/1174) Retired Windows Phone Silverlight
- [**#1099**](https://github.com/reactiveui/ReactiveUI/pull/1099) Changed `LaunchActivatedEventArgs` to `IActivatedEventArgs`
- [**#1045**](https://github.com/reactiveui/ReactiveUI/pull/1045) Add Universal Windows Platform (UWP) support
- [**#940**](https://github.com/reactiveui/ReactiveUI/pull/940) Update platform UAP 10069 -> UWP 10240, add Events and Testing projects
**Xamarin Android**
- [**#1186**](https://github.com/reactiveui/ReactiveUI/pull/1186) Android timepicker now uses `Hour`/`Minute` instead of `CurrentHour`/`CurrentMinute`
- [**#1144**](https://github.com/reactiveui/ReactiveUI/pull/1144) Small bug fixes to `ReactiveRecyclerViewAdapter` and `ViewHolder`
- [**#1105**](https://github.com/reactiveui/ReactiveUI/pull/1105) Add `ReactiveAppCompatActivity`
- [**#1095**](https://github.com/reactiveui/ReactiveUI/pull/1095) Add `AsObservable` when `ISubject` is returned as `IObservable`
- [**#1067**](https://github.com/reactiveui/ReactiveUI/pull/1067) Add Android reactive preferences
- [**#1059**](https://github.com/reactiveui/ReactiveUI/pull/1059) Add Rx implementation of the Android shared preferences changed
- [**#1058**](https://github.com/reactiveui/ReactiveUI/pull/1058) Add Rx implementation of the Android USB permission request
- [**#1057**](https://github.com/reactiveui/ReactiveUI/pull/1057) Add Rx implementation of the Android service bind
- [**#1044**](https://github.com/reactiveui/ReactiveUI/pull/1044) Resolve an issue building android support project
- [**#985**](https://github.com/reactiveui/ReactiveUI/pull/985) Add `serializer.Serialize(st, state);` into `SaveState`
- [**#982**](https://github.com/reactiveui/ReactiveUI/pull/982) Add a basic reactive adapter for the Android `RecyclerView`
- [**#939**](https://github.com/reactiveui/ReactiveUI/pull/939) Add a reactive version of the `Android.Support.V4.DialogFragment` class
- [**#885**](https://github.com/reactiveui/ReactiveUI/pull/885) Add a `ControlFetcherMixin` for the Android Support library
**Xamarin Forms**
- [**#1160**](https://github.com/reactiveui/ReactiveUI/pull/1160) Use non-generic `BindableProperty.Create`, since the generic overloads are deprecated
- [**#952**](https://github.com/reactiveui/ReactiveUI/pull/952) [**#1115**](https://github.com/reactiveui/ReactiveUI/pull/1115) Add support for view activation
- [**#942**](https://github.com/reactiveui/ReactiveUI/pull/942) [**#1074**](https://github.com/reactiveui/ReactiveUI/pull/1074) [**#1071**](https://github.com/reactiveui/ReactiveUI/pull/1071) [**#986**](https://github.com/reactiveui/ReactiveUI/pull/986) Lots of routing fixes and improvements
- [**#1032**](https://github.com/reactiveui/ReactiveUI/pull/1032) Add reactive pages
- [**#921**](https://github.com/reactiveui/ReactiveUI/pull/921) Add reactive cells
- [**#953**](https://github.com/reactiveui/ReactiveUI/pull/953) Upgrade Xamarin Forms dependency
- [**#951**](https://github.com/reactiveui/ReactiveUI/pull/951) Throw a useful exception from `ViewModelViewHost` if the view is of the wrong type
- [**#950**](https://github.com/reactiveui/ReactiveUI/pull/950) Use `ContentView` as base class for `ViewModelViewHost`
- [**#919**](https://github.com/reactiveui/ReactiveUI/pull/919) Fix `ViewModelViewHost` bug where collection is modified whilst being enumerated
- [**#861**](https://github.com/reactiveui/ReactiveUI/pull/861) Retarget ReactiveUI.Xamforms to Profile259
- [**#1153**](https://github.com/reactiveui/ReactiveUI/pull/1153) Update reactiveui-xamforms nuspec dependency from v2.1.0.6529 to v2.3.1.114
- [**#1152**](https://github.com/reactiveui/ReactiveUI/pull/1152) Upgrade reactiveui-core for Xamarin.Forms from v2.2.0.31 to v2.3.1.114
- [**#1150**](https://github.com/reactiveui/ReactiveUI/pull/1150) Upgrade reactiveui-events for Xamarin.Forms from v2.2.0.31 to v2.3.1.114
- [**#1196**](https://github.com/reactiveui/ReactiveUI/pull/1196) Resolve a crash when using `ViewModelViewHost` with Xamarin Forms
**Xamarin iOS**
- [**#1182**](https://github.com/reactiveui/ReactiveUI/pull/1182) Use `ViewWillAppear` for iOS activation (not `ViewDidAppear`)
- [**#1176**](https://github.com/reactiveui/ReactiveUI/pull/1176) Migrate reactiveui-testing from Monotouch to Xamarin.iOS
- [**#1087**](https://github.com/reactiveui/ReactiveUI/pull/1087) Make `ReactiveNavigationController` activatable
- [**#1086**](https://github.com/reactiveui/ReactiveUI/pull/1086) Fix various `RoutedViewHost` issues
- [**#927**](https://github.com/reactiveui/ReactiveUI/pull/927) Rewrite `CommonReactiveSource` to be reactive and fix numerous bugs
- [**#917**](https://github.com/reactiveui/ReactiveUI/pull/917) Add `ReactiveSplitViewController`
- [**#874**](https://github.com/reactiveui/ReactiveUI/pull/874) Make iOS `ViewModelViewHost` an actual view controller
- [**#873**](https://github.com/reactiveui/ReactiveUI/pull/873) Fix a `CommonReactiveSource` race condition by ensuring that batched changes result in `BeginUpdates` call ASAP
- [**#1177**](https://github.com/reactiveui/ReactiveUI/pull/1177) Fix code generation of events with iOS 10
**Xamarin Mac**
- [**#1185**](https://github.com/reactiveui/ReactiveUI/pull/1185) Use Xamarin.Mac framework for reactiveui/reactiveui-testing/microsoft-reactive-testing
- [**#1175**](https://github.com/reactiveui/ReactiveUI/pull/1175) Xamarin.Mac (unified) now compiles on windows
- [**#1022**](https://github.com/reactiveui/ReactiveUI/pull/1022) Add `ViewAttributes` to Xamarin.Mac projects
- [**#916**](https://github.com/reactiveui/ReactiveUI/pull/916) Fix `ViewModelViewHost` on Mac
- [**#887**](https://github.com/reactiveui/ReactiveUI/pull/887) Changed output to Xamarin.Mac20 to reflect reality and added .nuspec
**Housekeeping**
- [**#1188**](https://github.com/reactiveui/ReactiveUI/pull/1188) Upload .dll artefacts to AppVeyor on successful build
- [**#1179**](https://github.com/reactiveui/ReactiveUI/pull/1179) Run unit tests as part of continuous integration pipeline
- [**#1178**](https://github.com/reactiveui/ReactiveUI/pull/1178) Resolved an issue with continuous integration pipeline
- [**#1148**](https://github.com/reactiveui/ReactiveUI/pull/1148) Bootstrapper now downloads/installs Android API level 24
- [**#1140**](https://github.com/reactiveui/ReactiveUI/pull/1140) Add GitHub issue/PR templates
- [**#1128**](https://github.com/reactiveui/ReactiveUI/pull/1128) Enable strict mode (fail the build on any powershell error)
- [**#1092**](https://github.com/reactiveui/ReactiveUI/pull/1092) Continuous integration and pre-release builds for v7
- [**#1010**](https://github.com/reactiveui/ReactiveUI/pull/1010) Compiler warnings for events disabled to reduce CI log spam
**Documentation**
- [**#1003**](https://github.com/reactiveui/ReactiveUI/pull/1003) Initial revamp of README.md
- [**#898**](https://github.com/reactiveui/ReactiveUI/pull/898) Update compelling example in README.md for v6.x
### Where to get it
You can download this release from [nuget.org](https://www.nuget.org/packages/reactiveui/7.0.0)
---
### 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](https://github.com/reactiveui/reactiveui/compare/7.0.0...7.1.0) which resulted in [4 issues](https://github.com/reactiveui/ReactiveUI/issues?milestone=5&state=closed) being closed.
**All Platforms**
- [**#1225**](https://github.com/reactiveui/ReactiveUI/pull/1225) fix: reactiveui NuGet packages should be pinned and only work with packages from the same release
- [**#1218**](https://github.com/reactiveui/ReactiveUI/pull/1218) fix: subscription leakage in `ReactiveCommand`
**Xamarin Android**
- [**#1217**](https://github.com/reactiveui/ReactiveUI/pull/1217) feature: allow `WireUpControls` to find `View` members
**Xamarin iOS**
- [**#1216**](https://github.com/reactiveui/ReactiveUI/pull/1216) feature: added generic reactive controllers and views for iOS and Mac
**Xamarin Mac**
- [**#1216**](https://github.com/reactiveui/ReactiveUI/pull/1216) feature: added generic reactive controllers and views for iOS and Mac
### Where to get it
You can download this release from [nuget.org](https://www.nuget.org/packages/reactiveui/7.1.0)
---
### 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](https://github.com/reactiveui/reactiveui/compare/7.2.0...7.3.0) which resulted in [17 issues](https://github.com/reactiveui/ReactiveUI/issues?milestone=7&state=closed) being closed.
__All Platforms__
- [__#1325__](https://github.com/reactiveui/ReactiveUI/pull/1325) fix: schedule output of ReactiveCommand.Execute
- [__#1317__](https://github.com/reactiveui/ReactiveUI/pull/1317) refactor: removed unused extension method and make class internal
- [__#1306__](https://github.com/reactiveui/ReactiveUI/pull/1306) refactor: use xunit IsType in unit tests
__Xamarin Android__
- [__#1302__](https://github.com/reactiveui/ReactiveUI/pull/1302) feature: improved exception message when there are multiple resource IDs with the same name
__Xamarin Mac__
- [__#1259__](https://github.com/reactiveui/ReactiveUI/issues/1259) bug: the assembly for Xamarin.Mac20 in the reactiveui-events NuGet package was not included
__Housekeeping__
- [__#1331__](https://github.com/reactiveui/ReactiveUI/pull/1331) housekeeping: use hello@reactiveui.net for all communication
- [__#1313__](https://github.com/reactiveui/ReactiveUI/pull/1313) housekeeping: add table of contents with relative links
- [__#1326__](https://github.com/reactiveui/ReactiveUI/pull/1326) housekeeping: add backers and sponsors from Open Collective
__Documentation__
- [__#1323__](https://github.com/reactiveui/ReactiveUI/pull/1323) chore: tidy up ReactiveCollectionMixin xml comments
- [__#1322__](https://github.com/reactiveui/ReactiveUI/pull/1322) chore: tidy up xml comments in PropertyBinding
- [__#1321__](https://github.com/reactiveui/ReactiveUI/pull/1321) chore: tidy up xml comments in OrderedComparer
- [__#1320__](https://github.com/reactiveui/ReactiveUI/pull/1320) chore: improved ObservedChangedMixin xml documentation
- [__#1319__](https://github.com/reactiveui/ReactiveUI/pull/1319) chore: tidy up XMLDOC in ObservableAsPropertyHelper
- [__#1310__](https://github.com/reactiveui/ReactiveUI/pull/1310) chore: tidy xml documentation for AutoPersistHelpers
- [__#1308__](https://github.com/reactiveui/ReactiveUI/pull/1308) chore: tidy xml comments in RegisterableInterfaces
- [__#1307__](https://github.com/reactiveui/ReactiveUI/pull/1307) chore: tidy up xml comment
- [__#1309__](https://github.com/reactiveui/ReactiveUI/pull/1309) chore: fix xml doc referencing type with generic arguments
### Where to get it
You can download this release from [nuget.org](https://www.nuget.org/packages/reactiveui/7.3.0)
---