diff --git a/Rx.NET/Documentation/adr/0003-multi-platform-packaging.md b/Rx.NET/Documentation/adr/0003-multi-platform-packaging.md new file mode 100644 index 000000000..2aa6b0025 --- /dev/null +++ b/Rx.NET/Documentation/adr/0003-multi-platform-packaging.md @@ -0,0 +1,315 @@ +# NuGet packages and multi-platform support + +Rx has tried a few strategies for cross-platform support over its history. The approach used currently in Rx (from v4.0 to v6.0) has turned out to cause problems for some UI frameworks on the latest versions of .NET: self-contained deployments would end up including copies of various WPF and Windows Forms components whether they used them or not, causing binaries to be tens of megabytes larger than they otherwise would have been. (https://github.com/AvaloniaUI/Avalonia/issues/9549 describes one example of this problem.) + +This ADR describes a change in approach designed to address this. + +## Status + +Proposed + +## Context + +Rx has always run on multiple .NET platforms. This caused two distinct but related challenges. First, some parts of Rx (notably the way schedulers use threads) depend on platform functionality (such as thread pools) that is slightly different across different flavours of .NET—for these parts, the public API surface area was the same, but the underlying implementation was platform-specific. Second, there were some platform-specific API features, such as schedulers that integrate with WPF—the public API offered by Rx varied slightly according to your target platform. Several different strategies for dealing with these two issues have been tried over the years: + +* In v1, Microsoft built multiple different versions of the Rx libraries for different platforms. (This was long before .NET Standard or even before Portable Class Libraries.) +* v2 was designed to take advantage of the (then new, now defunct) Portable Class Library (PCL) concept. Assemblies were in one of these categories: + * A portable core + * `System.Reactive.Interfaces` (in the [`Rx-Interfaces`](https://www.nuget.org/packages/Rx-Interfaces/2.2.5) NuGet package)—originally conceived as an assembly that would stay on v2.0.0.0 indefinitely, containing the canonical definitions of core interfaces + * `System.Reactive.Core` (in the [`Rx-Core`](https://www.nuget.org/packages/Rx-Core/2.2.5) NuGet package)—platform-independent schedulers, and utility types for implementing Rx operators + * `System.Reactive.Linq` (in the [`Rx-Linq`](https://www.nuget.org/packages/Rx-Linq/2.2.5) NuGet package)—implementations of LINQ operators for Rx + * The [v2.0 beta announcement](http://web.archive.org/web/20130522225545/http://blogs.msdn.com/b/rxteam/archive/2012/03/12/reactive-extensions-v2-0-beta-available-now.aspx) mentions `System.Reactive.Providers`—expression tree support for Rx LINQ—but I don't see this on NuGet, so I'm not sure if it got rolled into something else + * Platform-specific services, just one component, `System.Reactive.PlatformServices`, but the `Rx-PlatformServices` package contained builds for multiple target platforms including: + * .NET Framework 4.0 + * .NET Framework 4.5 + * Silverlight 5 + * Windows Phone (7, 7.1, and 8) + * PCL (various profiles, covering .NET Framework, Silverlight, and several versions of Windows Phone) + * UI-framework-specific functionality + * `System.Reactive.Windows.Threading` (in the [`Rx-Xaml`](https://www.nuget.org/packages/Rx-Xaml/2.2.5) NuGet package)—(WPF, WinRT, Silverlight, and Windows Phone schedulers and extension methods) + * `System.Reactive.Windows.Forms` (in the [`Rx-WinForms`](https://www.nuget.org/packages/Rx-WinForms/2.2.5) NuGet package)—(Windows Forms schedulers and extension methods) + * `System.Reactive.WindowsRuntime` (in the [`Rx-Metro`](https://www.nuget.org/packages/Rx-Metro/2.2.5) NuGet package)—(additional support for some WinRT-specific types for working with async operations) +* v3 changed the NuGet package names, but essentially kept the same structure + * The old `Rx-Main` metapackage is replaced by `System.Reactive` + * `Rx-Interfaces` becomes `System.Reactive.Interfaces` (version number changed to v3.0, not clear if there were actually interface changes) + * `Rx-Core` becomes `System.Reactive.Core` + * `Rx-Linq` becomes `System.Reactive.Linq` + * `Rx-PlatformServices` becomes `System.Reactive.PlatformServices` + * Likewise, the framework-specific libraries `System.Reactive.Windows.Threading`, `System.Reactive.Windows.Forms`, and `System.Reactive.WindowsRuntime` move into eponymous packages +* v4 made a major change: everything is now in a single `System.Reactive` package; the old packages still exist but now contain nothing by type forwarders pointing back into `System.Reactive`; targets `net46`, `uap10`, `uap10.0.16299`, and `netstandard2.0` +* v5 stuck with the same structure as v4; targets `net472`, `uap10.0.16299`, `netcoreapp3.1`, `net5.0`, `net5.0-windows10.0.19041`, and `netstandard2.0` +* v6 stuck with the same structure as v5 but with some newer frameworks; targets `net472`, `uap10.0.16299`, `net6.0`, `net6.0-windows10.0.19041`, and `netstandard2.0` + +The historical split between `System.Reactive.Windows.Threading` and `System.Reactive.WindowsRuntime` is a little baffling. It's not clear why some WinRT stuff ended up in its own library, and some shared a library with WPF, Silverlight, and Windows Phone. + +Up as far as v2, the `System.Reactive.PlatformServices` was based on a concept called "platform enlightenments". The purpose of this was to avoid having to provide a "lowest common denominator" implementation for the common API surface area. The portable core provided various schedulers, but some of these would be suboptimal on certain target platforms. Some platforms offered APIs that enabled better implementations, but because portable class libraries can access only the functionality common to their set of targets, these core libraries could not exploit that. However the core libraries provided an extensibility point where other libraries could, at runtime, plug in more specialized implementations suitable to the target platform that would provide better performance. These were called "enlightenments". + +There was a major change in v4. Superficially, this seemed to "just" merge all the separate components into a single one. The most visible benefit is that it seems simpler: you need just a single NuGet package reference. However, the history behind this is more complex than it may first appear. + +### History behind the decision to unify `System.Reactive` in v4 + +In v2, the core components contained both `net40` and `net45` targets. This could create an interesting problem in .NET applications that offered a plug-in model (e.g., Visual Studio extensions) reported in [issue #97](https://github.com/dotnet/reactive/issues/97). Imagine two plug-ins: + +* Plug-in A + * Targets .NET Framework 4.0 + * Has a reference to `System.Reactive.Linq` v3.0 +* Plug-in B + * Targets .NET Framework 4.5 + * Has a reference to `System.Reactive.Linq` v3.0 + +Plug-ins are typically developed independently of one another and independently of the host application. Each plug-in will have its own build process, and that build process is going to need to pick specific DLLs to place in its build output. For example, each of the plug-ins here needs to decide which of the many difference `System.Reactive.Linq.dll` files available in the various subfolders of the `lib` folder of the `System.Reactive.Linq` NuGet package to deploy. Since Plug-in A was built for .NET Framework 4.0, it's going to use the `lib\net40\System.Reactive.Linq.dll`. Plug-in B was built for .NET Framework 4.5, so even though it's built against the exact same NuGet version on `System.Reactive.Linq`, it's going to pick a different file: `lib\net45\System.Reactive.Linq.dll`. + +Suppose the host application runs in .NET 4.5, and it loads Plug-in A. This is OK because loading of .NET 4.0 components in a .NET 4.5 host process is supported. This plug-in will at some point load its copy of `System.Reactive.Linq.dll`. As we've established, since Plug-in A was built for .NET 4.0 it will have a copy of the `System.Reactive.Linq.dll` that was in the `lib\net40` folder in the `System.Reactive.Linq` NuGet package. So it gets to use the version it was built for. + +So far, so good. + +Now suppose the host loads Plug-in B. It will also want to load `System.Reactive.Linq.dll`, but the CLR will notice that it has already loaded that component. The critical detail here is that the `System.Reactive.Linq.dll` files in the `lib\net40` and `lib\net45` folders have **the same name, public key token, and version number**. The .NET Framework assembly loader therefore considers them to have the same identity, despite being different files with different contents. So when Plug-in B comes to try to use `System.Reactive.Linq.dll`, the loader will just use the same one that was loaded on behalf of Plug-in A. (It won't even look at Plug-in B's copy, because it has every reason to believe that it is identical—it has the exact same fully-qualified name, after all.) But if Plug-in B is relying on any functionality specific to the `net45` version of that component, it will be disappointed, and we will runtime errors such as `MethodNotFoundException`. + +This tends not to be an issue with modern versions of .NET because we have [`AssemblyLoadContext`]([https://learn.microsoft.com/en-us/dotnet/core/dependency-loading/understanding-assemblyloadcontext) to solve this very problem. But with .NET Framework, this was a serious problem for plug-in hosts. There are some important plug-in hosting apps that still use .NET Framework (notably Visual Studio) so this problem hasn't gone away. + +In 2016, Rx v3.0 attempted to address this in [PR #212](https://github.com/dotnet/reactive/pull/212) by giving a slightly different version number to each target. For example, the `net45` DLL had version 3.0.1000.0, while the `net451` DLL was 3.0.2000.0, and so on. This plan is described in [issue #205](https://github.com/dotnet/reactive/issues/205). + +At the time this was proposed, it was [acknowledged](https://github.com/dotnet/reactive/issues/205#issuecomment-228577028) that there was a potential problem with binding redirects. Binding redirects often specify version ranges, which means if you upgrade 3.x to 4.x, it's possible that 3.0.2000.0 would get upgraded to 4.0.1000.0, which could actually mean a downgrade in surface area (because the x.x.2000.0 versions might have target-specific functionality that the x.x.2000.0 versions do not). + +There were other issues in practice. [Issue #305](https://github.com/dotnet/reactive/issues/305) shows one example of the baffling kinds of problems that could emerge. + +This led to the decision to restructure Rx so that it is all in a single DLL. This solved the problem described in #305: if Rx is just one DLL, you can't get into a situation in which different bits of Rx seem to disagree about which Rx version is in use. If Rx is only one binary, then there's no scope for getting a mixture of versions. + +### Revisiting the decisions in 2023 + +To recap, there are two particularly significant factors that led to the decision in 2016 use per-target-framework version numbers (which in turn led to the decision to package Rx as a single DLL): + +* There were builds for multiple .NET 4.x frameworks +* The `AssemblyLoadContext` was unavailable + +The problem with .NET 4.x is that any component built for any .NET 4.x target could also end up loading on a later version of .NET 4.x (e.g., a `net40` component could load on `net462`) and once that happens in some process, that process will no longer be able to load a different file that is nominally the same version of the same component but which targets a newer framework. (E.g., once .NET 4.8 has loaded the `net40` build of some particular version of some component, then it won't be able to go on to load the `net48` version of the same nominal version of that component.) **Note**: this is only a problem when two plug-ins want the same nominal version of Rx but different targets. .NET Framework is perfectly capable of loading two completely different versions of Rx. (If two plug-ins depend on Rx 5.0 and Rx 6.0, then both the 5.0 and 6.0 versions of Rx can be loaded into the same process, the same AppDomain even. Assembly binding redirects could force both components onto a newer version, but there's no situation in which loading a plug-in with a dependency on an older version of Rx before loading one with a dependency on a newer version will cause that second plug-in to be unable to load. The v2 era problems only arose when both plug-ins wanted the same version of Rx but were targeting different versions of .NET Framework.) + +But if you look at Rx 6.0 (the current version in 2023) we now build only a single .NET Framework target, `net472`. It seems that this original problem has gone away, so perhaps we can unwind the decisions that led to the current design. + +A possible fly in the ointment is the `netstandard2.0` component, because that could in principle run in a .NET Framework process. We could still end up with that loading first, blocking any attempt to load the `net472` version some time later. However, in the plug-ins scenario above, that shouldn't happen. The build processes for the individual plug-ins know they are targeting .NET Framework, so they should prefer the `net472` version over the `netstandard2.0` one. (If they target an older version such as `net462`, then perhaps they would pick `netstandard2.0` instead. But then the current Rx 6.0 design fails in that scenario too. So unwinding the earlier design decisions won't make things any worse than they already are.) + +Another consideration is that modern NuGet tooling is better than it was in 2016 when the current design was established. Alternative solutions might be possible now that would not have worked when Rx 4.0 was introduced. + +When it comes to .NET 6.0 and later, these problems should a non-issue because better plug-in architectures exist thanks to `AssemblyLoadContext`. + +So for all these reasons, while the current design might have been the best option when Rx 4.0 was released, there are likely to be other options today, and these might enable us to solve the new problems that have increasing use of new UI frameworks, and .NET build techniques such as trimming. + +### The problems that any new solution has to solve + +To be able to evaluate potential design changes, we need to understand the problems that any solution must solve. There are the original two problems that motivated the current design, and the newer problems that only occurred with more recent frameworks. And there is also a backwards compatibility constraint. + +1. Host applications with a plug-in model getting into a state where plug-ins disagree about which `System.Reactive.dll` is loaded for a particular version of Rx (i.e., when there are multiple candidate targets) +2. Incompatible mixes of version numbers of Rx components +3. Applications getting WPF and Windows Forms dependencies even though they use neither of these frameworks. +4. Components that have a dependency on Rx 5.0 or 6.0 running in an application that upgrades that to Rx 7.0 (they must not be broken by this upgrade). + +It's worth re-iterating that 1 is a non-issue on .NET 6.0+ hosts. Applications hosting plug-ins on those runtimes will use `AssemblyLoadContext`, enabling each plug-in to make its own decisions about which components. If plug-ins make conflicting decisions, it doesn't matter, because `AssemblyLoadContext` is designed to allow that. + +Rx 3.0 solved 1 by using different 'build numbers' (the 3rd part of the assembly version) for different targets. For example, DLLs targeting `net45` would have a version of 3.0.1000.0; `net451` DLLs used 3.0.2000.0; `net46` DLLs used 3.0.3000.0. These assembly version numbers remained the same across multiple NuGet releases, so even in the release that NuGet labels as 3.1.1, the assembly version numbers were all 3.0.xxxx.0. So if a plug-in built for .NET 4.0 used Rx 3.1.1, and was loaded into the same process as another plug-in also using Rx 3.1.1 but built for .NET 4.5, they would be able to load the two different `System.Reactive.Linq.dll` assemblies because those assemblies had different identities by virtue of having different assembly version numbers. Unfortunately, while this solved problem 1, it caused problem 2: it was relatively easy to confuse NuGet into thinking that you had conflicting dependencies. + +It's worth noting that problem 2 goes away if you use the modern project system. The problem described in [#305](https://github.com/dotnet/reactive/issues/305) occurs only with the old `packages.config` system. If you try to reproduce the problem in a project that uses the [.NET SDK](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview) project system introduced back in MSBuild 15 (Visual Studio 2017), the problem won't occur. Visual Studio 2017 is the oldest version of Visual Studio with mainstream support. + +Rx 4.0 solved 2 (and Rx 6.0 uses the same approach) by collapsing everything down to a single NuGet package, `System.Reactive`. To access UI-framework-specific functionality, you no long needed to add a reference to a UI-framework-specific package such as `System.Reactive.Windows.Forms`. From a developer's perspective, the functionality was right there in `System.Reactive`. The exact API surface area you saw was determined by your target platform. If you built a UWP application, you would get the `lib\uap10.0.16299\System.Reactive.dll` which had the UWP-specific dispatcher support built in. If your application was built for `net6.0-windows10.0.19041` (or a .NET 6.0 TFM specifying a later Windows SDK) you would get `lib\net6.0-windows10.0.19041\System.Reactive.dll` which has the Windows Forms and WPF dispatcher and related types build in. If your target was `net472` or a later .NET Framework you would get `lib\net472\System.Reactive.dll`, which also included the Windows Forms and WPF dispatcher support (but built for .NET Framework, instead of .NET 6.0). And if you weren't using any client-side UI framework, then the behaviour depended on whether you were using .NET Framework, or .NET 6.0+. With .NET Framework you'd get the `net472` DLL, which would include the WPF and Windows Forms support, but it didn't really matter because those frameworks were present as part of any .NET Framework installation. And if you target .NET 6.0 you'll get the `lib\net6.0\System.Reactive.dll`, which has no UI framework support, but that's fine because any .NET 6.0+ TFM that doesn't mention 'windows' doesn't offer either WPF or Windows Forms. + +Rx 4.0, 5.0, and 6.0 don't have a solution to 3. Initially they didn't need one—in the scenarios where you got WPF and Windows Forms support without really needing it, it was of little consequence. If you were running on .NET Framework, those frameworks were pre-installed, so there was no cost to having a dependency on them. And at the time, if your target was `netcoreapp3.1-windowsXX` it was almost invariably because you were building a WPF or Windows Forms app. However, two important things have changed in recent years: 1) there are now a lot of other UI frameworks besides WPF and Windows Forms, and 2) it's now common to produce some sort of self-contained deployment for client-side apps, at which point dragging along copies of both WPF and Windows Forms when you are using neither makes applications far larger than they should be. + +### Types in `System.Reactive` that are partially or completely UI-framework-specific + +Unwinding the consolidation that happened in V4 comes with a challenge: `System.Reactive` now has a slightly different API surface area on different platforms. There are some types available only on specific targets. There is one type that is available on all targets but has a slightly different public API on one target. And there are some types with the same API surface area on all targets but with differences in behavior. This section describes the afflicted API surface area. + +Types available only in specific targets: + +* `net472` + * `RemotingObservable` +* `net6.0-windows` and `net472` + * `DispatcherScheduler` + * `DispatcherObservable` +* `net6.0-windows*` and UWP + * `CoreDispatcherScheduler` + * `CoreDispatcherObservable` + * Windows Foundation Event Handler support: + * `IEventPatternSource` + * `EventPatternSource` + * `WindowsObservable` (see also async operations) + * Adaptation between `IObservable` and WinRT's async actions/operations/progress: + * `AsyncInfoObservableExtensions` + * `AsyncInfoObservable` + * `WindowsObservable` (see also Windows Foundation Event Handler support) + +Types that are in all targets, but which contain UI-frameworks specific public members in relevant targets: + +* UWP + * `ThreadPoolScheduler` has different implementation based on UWP thread pool and provides support for `WorkItemPriority` (a UWPism) + +Behavior that is different across platforms: + +* UWP + * `Scheduler` periodic scheduling has workaround for WinRT not supporting <1ms resolution +* `net6.0-windows*` and UWP + * `IHostLifecycleNotifications` service available from enlightenment provider + * Periodic scheduling will be aware of windows suspend/resume events only if using `System.Reactive` for these targets + + +### Design options + +Here are some possible design changes that could solve some new problems without re-introducing old ones. + +For each option the first question we have to ask is whether we will revert to the old approach of putting framework-specific code in separate components, or maintain the current unified `System.Reactive` structure. Even if we make the choice to reinstate the pre-Rx-v4.0 situation in which UI-framework-specific functionality is accessed through UI-framework-specific NuGet packages, there are still two dimensions to consider. Rx has platform-specific API surface area. (E.g., `System.Reactive.Concurrency.ControlScheduler` is a scheduler that supports the Windows Forms threading model.) More subtly, there have long been platform-specific implementation details. (E.g., on UWP, you aren't allowed to create new `Thread` objects, which constrains the implementation of some schedulers. There are some schedulers for which it would be possible to produce a single implementation that could run on all platforms, but where use of `Thread` would result in better performance where it is available. So although a 'lowest common denominator' implementation is possible, it is undesirable—developers targeting .NET 6.0 shouldn't be penalized for limitations that happen to exist in UWP. For this reason, some of the schedulers compiled into `System.Reactive` in Rx 6.0 have different code on different platforms.) Design options will need to be able to address both of these "multi-platform" aspects. + +Back before the 'great unification' in Rx v4.0, the distinction between these two aspects was reflected by the NuGet packaging. As just discussed, framework-specific API surface area was in platform-specific packages. But the second concern of implementation details was handled through the 'platform enlightenment' concept, which was visible through the `System.Reactive.PlatformServices` component. + +With that in mind, let's now consider some possible choices. + + +#### Design option: the status quo + +Rx 5.0 and 6.0 have both shipped, and a lot of people use them, so one option is just to continue doing things in the same way. This is not a good solution. Back when Rx 5.0 was the current version, some people seemed to think that the changes we adopted in Rx 6.0 would be sufficient to solve the problems described in this document. But as will be explained, it doesn't. + +`System.Reactive` 5.0 targeted `netstandard2.0`, `net472`, `netcoreapp3.1`, `net5.0`, `net5.0-windows10.0.19041`, and `uap10.0.16299`. The idea with this design option was to target `netstandard2.0`, `net472`, `net6.0`, `net6.0-windows10.0.19041`, and `uap10.0.16299`. (In other words, drop .NET Core 3.1 and .,NET 5.0, both of which went out of support in 2022, and effectively upgrade the .NET 5.0 target to .NET 6.0.) This is in fact exactly what we did for Rx 6.0, but despite what some people seemed to believe, this was never going to solve the problems described above. + +(Some people also seemed to be demanding `net7.0` targets. I would be very reluctant to do that unless there are .Net 7.0 platform features we could use that would enhance functionality or performance that would justify offering both `net6.0` and `net7.0` targets. So unless we discover some unique benefits from targeting `net7.0`, I (@idg10) would prefer to state clearly that we support running on .Net 7.0, and to run all tests against both .Net 6.0 and 7.0, but not to produce `net7.0` targets if the only reason is to stop people complaining. That would be a technical solution to a social problem. And it's not even a good technical solution.) + +Let's look at how this gets on with the three challenges: + +**1: Host applications with a plug-in model getting into a state where plug-ins disagree about which `System.Reactive.dll` is loaded** + +Since the plug-in issues are only relevant to .NET Framework, and this doesn't change the .NET Framework packaging in any way, this solves the problem in the same way that Rx 4.0 and 5.0 do. + +**2: Incompatible mixes of version numbers of Rx components** + +Rx 4.0 introduced the unified packaging to solve this problem, and this option retains it, so it will solve the problem in the same way. + +**3. Applications getting WPF and Windows Forms dependencies even though they use neither of these frameworks** + +This design option does not solve this problem. I think this is a fundamental problem with anything that continues to have a unified structure: if `System.Reactive` inevitably gives you WPF and Windows Forms support whenever you target a `netX.0-windowX`-like framework, you're going to have this problem. There has to be some way to indicate whether or not you want that, and I think separating out those parts is the only way to achieve this. + +This design option also doesn't have a good answer for how we provide UI-framework-specific support for other frameworks. (E.g., how would we offer a `DispatcherScheduler` for MAUI's `IScheduler`?) + +So in short, I (@idg10) haven't been able to think of a design that maintains the unified approach that doesn't also suffer from problem 3. + +The only attraction of this design option is that it is least likely to cause any unanticipated new problems, because it closely resembles the existing design. + +#### Design option: deprecate `System.Reactive` + +* A `System.Reactive.Core` component (comprising the common public API, and common implementation details) with netstandard2.0, and .net6.0 (no `net472`, `uap10*`, or `*-windows` targets) +* UI-framework-specific components defining Rx types (e.g, `ControlDispatcher`, and `ControlObservable`) are supplied in per-framework components (e.g., `System.Reactive.Windows.Forms`, `System.Reactive.Maui`, `System.Reactive.Wpf`; the old multi-platform `System.Reactive.Windows.Threading` would exist for backcompat, but would just contain type forwarders); a new `UwpThreadPoolScheduler` would be made available for the UWP-specific version of the thread pool scheduler +* `System.Reactive` is deprecated, and retained only for backwards compatibility; it remains a component with platform-specific targets (net472, .net6.0 (with and without `-windows`), uap10) and also `netstandard2.0` and it just provides type forwarders for the entire V6 public surface area +* No version number adjustment within Rx versions—assemblies are all version 7.0.0.0 in Rx 7.0 (or 8.0.0.0 in Rx 8.0, etc.) + +Let's address the elephant in the room: this is almost exactly the design we had back in Rx v2.0. (The differences are that some older UI frameworks have gone away, and in this design, instead of having the strange "UI-framework-specific APIs for several, but not all UI frameworks" package known as `System.Reactive.Windows.Threading`, we move to a strict "one package per UI framework" model.) We know this didn't work in 2016, so why would we move back to it? + +Well a lot of things have changed since 2016. So let's look at the four problems it needs to solve. + +**1: Host applications with a plug-in model getting into a state where plug-ins disagree about which `System.Reactive.dll` is loaded** + +This problem ([issue #97](https://github.com/dotnet/reactive/issues/97)) arose because Rx NuGet packages contained two different DLLs with identical strong names, either of which could be loaded into the same .NET Framework host process. In this proposal that can't happen. The following bullet points explain why each of the packages described is immune to this (because the reasoning is slightly different for each set): + +* `System.Reactive.Core`: since only one target (`netstandard2.0`) can be loaded by .NET Framework, disagreement can't arise about which DLL represents any single assembly identity +* `System.Reactive`: this is trickier because there are two targets that could be loaded into a .NET Framework process: `net472` and `netstandard2.0`; however all currently tooling will select the `net472` version for any .NET Framework project using 4.7.2 or later (and Rx 5.0 and 6.0 already didn't support plug-in scenarios for hosts using older versions of .NET Framework) +* As for the UI-specific packages, because this plug-in problem exists only for .NET Framework, not .NET 6.0+, we only have to consider the Window Forms and WPF ones, and only the .NET Framework versions of those; these will have just one applicable target (`net472`) so the problem will not arise + +**Note:** for future versions of Rx, a critical aspect of this design is that we can't offer both `net472` and `net48` targets. We can certainly _support_ `net48`, but it is supported by offering a `net472` version. Since .NET Framework is at a point where Microsoft is not planning any significant new feature development, this shouldn't be a problem. The only situation in which we envisaging adding `net48` as a target would be if we were dropping support for `net472`, so we'd still have just one .NET Framework target. + + +**2: Incompatible mixes of version numbers of Rx components** + +This problem ([#305](https://github.com/dotnet/reactive/issues/305)) arose because Rx 3.0 played games with .NET assembly version numbers to solve [issue #97](https://github.com/dotnet/reactive/issues/97). But in this design option, we are not playing any such games, because issue 97 is addressed without needing to resort to such tricks. + +As it happens, the extent of this second problem has shrunk dramatically thanks to change in tooling. Even if we did use versioning tricks, it turns out that if you use the modern ".NET SDK" style of project, NuGet handles this situation correctly. But since we aren't planning to do that, this design option eliminates this problem even for the old project system. + +**3: Applications getting WPF and Windows Forms dependencies even though they use neither of these frameworks** + +This problem is relevant only to .NET 6.0+ applications. (It's not a problem on .NET Framework, because WPF and Windows Forms are invariably deployed as part of the runtime—there is no deployment model for .NET Framework in which applications ship their own copy of WPF or Windows Forms unless they have chosen to incorporate a complete .NET Framework installer.) + +This design option solves this by not having any `.net6.0-windowsXXX` targets in `System.Reactive.Core`. It targets `.net6.0` but not `.net6.0-windows10.0.19041`. `System.Reactive` continues to target `-windows` type TFMs, but in this design it is deprecated, and retained only for backwards compatibility. This means `System.Reactive.Core` cannot possibly take a dependency on either WPF or Windows Forms. That means that any applications or libraries targeting other UI frameworks such as WinUI, MAUI, or Avalonia can take a dependency on `System.Reactive.Core` without bringing in any WPF or Windows Forms code. You will only end up with a dependency on those frameworks if you use the corresponding `System.Reactive.Windows.Forms` or `System.Reactive.Wpf` NuGet packages. + +Applications wishing to take advantage of this will need to change their references from `System.Reactive` to `System.Reactive.Core`. + +One limitation of this scheme is that any applications picking up an indirect reference to `System.Reactive` will continue to have the problem in which they end up with dependencies on all of WPF and Windows Forms. + +**4: Components with a dependency on Rx 5.0 or 6.0 must not be broken if an app upgrades that to Rx 7.0** + +In normal (non-plug-in) usage, an application might take a dependency on multiple components that depend on different versions of Rx. NuGet has a complete view of the dependency tree (something that wasn't true back in the `packages.config` days). When building an application, it will pick a single version, so no matter which versions individual libraries depended on, a single version will be selected. (If some projects or libraries impose constraints, NuGet might not be able to resolve a suitable single version. For example, if you use a library that declares that it must have exactly Rx 5.0, and not a later version, and another library that declares that it must have Rx 6.0 or later, there is not satisfactory resolution. But that's not something we can solve.) + +Imagine a NuGet package `Example.LibUsingRx5` that targets `net6.0-windows10.0.19041`, and that references `System.Reactive` v5.0. Now suppose we have an application that targets `net8.0-windows10.0.22000` that references `Example.LibUsingRx5`. NuGet will determine that `System.Reactive` v5.0 meets all requirements, and it will use the package's `lib\net5.0-windows10.0.19041\System.Reactive.dll`. (The fact that it targets .NET 5.0, and not a .NET 6.0 or 8.0 TFM doesn't matter. All `net5.0` TFMs are compatible with the .NET 6.0, 7.0, and 8.0 runtimes.) + +Now imagine our application adds a reference to `Example.LibUsingRx6` that targets `net6.0`, and that references `System.Reactive` v6.0. This means that `System.Reactive` v6.0 now becomes the minimum acceptable version, and so `Example.LibUsingRx5` (which the app is still using, in addition to `Example.LibUsingRx6`) will also get upgraded to `System.Reactive` v6.0. Because the application targets `net8.0-windows10.0.22000`, NuGet is going to pick the Windows-specific TFM, so it will use the package's `lib\net6.0-windows10.0.19041\System.Reactive.dll`. + +Note that so far, using just the existing versions of Rx, the behavior is that this makes all the WPF and Windows Forms functionality available, creating dependencies on those frameworks. + +So far, that's all stuff that happens with today's version of Rx. So what about this putative Rx 7.0 in the design suggested? Imagine the app getting a third package reference, this time to `Example.LibUsingRx7` that targets `net6.0`, and that references `System.Reactive` v7.0. That makes v7.0 the minimum acceptable version of `System.Reactive`. In this design, `System.Reactive` includes a `net6.0-windows10.0.19041` target, and for that target it also has implicit references to `System.Reactive.Windows.Threading` and `System.Reactive.Windows.Forms`. And all targets have an implicit reference to `System.Reactive.Core` v7.0. So we'd get four DLLs loaded. + +* `System.Reactive` v7.0's `lib\net6.0-windows10.0.19041\System.Reactive.dll` +* `System.Reactive.Core` v7.0's `lib\net6.0\System.Reactive.Core.dll` +* `System.Reactive.Windows.Forms` v7.0's `lib\net6.0-windows10.0.19041\System.Reactive.Windows.Forms.dll` +* `System.Reactive.Windows.Threading` v7.0's `lib\net6.0-windows10.0.19041\System.Reactive.Windows.Threading.dll` + +In this design, `System.Reactive` is deprecated, and is retained for backwards compatibility. In this case it has caused the Windows Forms and WPF dependencies to be brought in. This is necessary because the `Example.LibUsingRx5` library targets `net6.0-windows10.0.19041`, so it could well be using these features. To ensure backwards compatibility, + +What about projects still using `packages.config`? + +### Design option: remove UI dependencies from `System.Reactive` + +The scheme described in [Design option: deprecate `System.Reactive`](#design-option-deprecate-systemreactive) had a limitation: any applications with a Windows-specific TFM that pick up an indirect reference to `System.Reactive` will continue to have the problem in which they end up with dependencies on all of WPF and Windows Forms. That means we might have the following extremely annoying situation: + +* `Example.NonUiLibUsingRx5`: a library targeting `net6.0` that uses Rx 5.0, and because it has a non-Windows-specific TFM, it can't possibly be using any Windows Forms or WPF features of Rx +* `Example.LibUsingThatLastLib`: a library targeting `net6.0` with a reference to `Example.NonUiLibUsingRx5`; this has an implicit reference to Rx 5.0, so it could be using Rx features, but since it also has a non-Windows-specific TFM, it can't possibly be using any Windows Forms or WPF features of Rx +* `MyAvaloniaApp`: an application that does not use WPF or Windows Forms, and which targets `net6.0-windows10.0.22000`, and which has a dependency on `Example.NonUiLibUsingRx5` and `System.Reactive.Core` v7 + +This will end up with a dependency on `System.Reactive` v5, and because it has a Windows-specific target, it will get the `lib\net5.0-windows10.0.19041\System.Reactive.dll` file from that package. (It will also have `System.Reactive.Core` from V7. So it will effectively have two different versions of Rx loaded.) Attempting to force that older library to use the newer version by referring to `System.Reactive` v7 won't help because that's the backwards compatibility package that continues to bring in dependencies on WPF and Windows Forms. + +This means that the only way the Avalonia app can free itself from this problem is if all of its Rx-using dependencies upgrade to Rx 7.0 and specify `System.Reactive.Core`, not `System.Reactive`. + +So could we instead change `System.Reactive` so that it continues to be the way to use Rx, and just make it so that it doesn't bring in WPF and Windows Forms dependencies? It would certainly be a relatively straightforward change: we'd move the relevant types out into separate assemblies as with [Design option: deprecate `System.Reactive`](#design-option-deprecate-systemreactive), but we'd just leave everything else in `System.Reactive` and have that target only `netstandard2.0` and `net6.0`. + +This would be a much more satisfying result. `System.Reactive` would continue to be the way to use Rx. But there's one big problem with this: it breaks backwards compatibility. + +Consider a WPF application targeting `net6.0-windows10.0.22000`. Imagine a NuGet package `Example.LibUsingRx5` that targets `net6.0-windows10.0.19041`, and that references `System.Reactive` v5.0, and suppose that this library was indeed using some WPF-specific functionality in Rx (e.g., the `DispatcherScheduler`). And suppose that this same application also depends on some other component `Example.NonLibUsingRxUpgradeable`, targeting `.net6.0`, where v1 of this component depends on Rx 5.0. So far all is well—we've got a dependency on WPF via Rx but that's fine because it's a WPF application. Now suppose a new v2 of `Example.NonLibUsingRxUpgradeable` is released, still targetting `net6.0`. and it now depends on Rx 7.0. NuGet is now going to determine that `System.Reactive` v5.0 no longer satisfies all components, so it determines that everything's going to get `System.Reactive` v7.0. But if we've modified that so that it no longer offers any of the Windows Forms or WPF functionality, we're now going to have a problem: when we exercise the code in `Example.LibUsingRx5` that was depending on the `DispatcherScheduler`, we're going to get a `MissingMethodException` at runtime! + +The application can't fix this even by explicitly taking a dependency on `System.Reactive.Windows.Threading`, because the `Example.LibUsingRx5` doesn't know the types have moved there. + +So the difference between this and [Design option: deprecate `System.Reactive`](#design-option-deprecate-systemreactive) is that you have to choose between `MissingMethodException` and unnecessary but unavoidable dependencies on WPF and Windows Forms. In either case the only way the application can avoid the problem is to avoid taking dependencies on libraries dependent on older versions of Rx. + + +### Rejected design options + +This section describes some ideas that have been rejected as unworkable. + +#### Unworkable Option 1 + +This next option is a slightly less radical change from Rx v6.0's design: + +* A `System.Reactive` component targeting `netstandard2.0`, `net472`, `net6.0`, `uap10` (with platform-appropriate implementation details, and a lowest common denominator for `netstandard2.0`), and the `net472` and `uap10` targets include support for the UI frameworks available on those targets (Windows Forms and WPF for `net472`, UWP for `uap10`) but the `net6.0` target has no UI framework support and we do **not** offer a `net6.0-windowsXX` target +* UI-framework-specific Rx types (e.g, `ControlDispatcher`, and `ControlObservable`) are baked into `System.Reactive` for the `net472` and `uap10` targets, but for all other cases are supplied in per-framework components (e.g., `System.Reactive.Windows.Forms`, `System.Reactive.Maui`, `System.Reactive.Wpf`; the old multi-platform `System.Reactive.Windows.Threading` would exist for backcompat, but would just contain type forwarders) + +The main attraction of this approach over option 1 is that this is a smaller change. I (@idg10) don't like it as much because it is less internally consistent, but it might be less disruptive for existing users, and it also has fewer separate components. Note that this sort of straddles the "framework-specific code in separate components" and "unified" approach, because it retains some of the aspects of the current unified design. (That's the main source of the inconsistency that I dislike.) + +Again, let's look at how this addresses the three challenges. + +**1: Host applications with a plug-in model getting into a state where plug-ins disagree about which `System.Reactive.dll` is loaded** + +Remember, this problem ([issue #97](https://github.com/dotnet/reactive/issues/97)) arose because Rx NuGet packages contained two different DLLs with identical strong names, either of which could be loaded into the same .NET Framework host process. But although the `netstandard2.0` and `net472` targets for `System.Reactive` could either technically be loaded into a .NET Framework process, in practice any component built for .NET Framework will pick the `net472` version, so as with the preceding option, this won't be a problem. + + +**2: Incompatible mixes of version numbers of Rx components** + +This problem ([#305](https://github.com/dotnet/reactive/issues/305)) arose because Rx 3.0 played games with .NET assembly version numbers to solve [issue #97](https://github.com/dotnet/reactive/issues/97). But in this design option, we are not playing any such games, because issue 97 is addressed without needing to resort to such tricks. + +**3: Applications getting WPF and Windows Forms dependencies even though they use neither of these frameworks** + +As with option 1, there is no `net6.0-windowsXX` target for `System.Reactive`, so this can't cause dependencies on WPF or Windows Forms. + +**4: Components with a dependency on Rx 5.0 or 6.0 must not be broken if an app upgrades that to Rx 7.0** + +Since this design option is essentially half-baked version of [Design option: remove UI dependencies from `System.Reactive`](#design-option-remove-ui-dependencies-from-systemreactive) (it leaves the dependencies in place for .NET Framework, but removes them for .NET 6.0) this runs into the same problem as described in that design. The only benefit is that you don't hit this problem if you happen to be targetting .NET Framework. + + + + +## Decision + +TBD, but currently my preferred approach is option 1. + +## Consequences + +TBD. \ No newline at end of file diff --git a/Rx.NET/Source/Directory.build.props b/Rx.NET/Source/Directory.build.props index 5861aeefb..1f25b7830 100644 --- a/Rx.NET/Source/Directory.build.props +++ b/Rx.NET/Source/Directory.build.props @@ -20,6 +20,28 @@ latest + + + Debug + AnyCPU + $(Platform) + + bin\ + $(BaseOutputPath)\ + $(BaseOutputPath)$(Configuration)\ + $(BaseOutputPath)$(PlatformName)\$(Configuration)\ + $(OutputPath)\ + + obj\ + $(BaseIntermediateOutputPath)\ + $(BaseIntermediateOutputPath)$(Configuration)\ + $(BaseIntermediateOutputPath)$(PlatformName)\$(Configuration)\ + $(IntermediateOutputPath)\ + + true snupkg diff --git a/Rx.NET/Source/System.Reactive.sln b/Rx.NET/Source/System.Reactive.sln index 6b821dc17..a48525548 100644 --- a/Rx.NET/Source/System.Reactive.sln +++ b/Rx.NET/Source/System.Reactive.sln @@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.5.33627.172 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive", "src\System.Reactive\System.Reactive.csproj", "{01706A0F-8A63-4FD6-AF45-0BC0BED3C0D9}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Base", "src\System.Reactive\System.Reactive.Base.csproj", "{01706A0F-8A63-4FD6-AF45-0BC0BED3C0D9}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Reactive.Testing", "src\Microsoft.Reactive.Testing\Microsoft.Reactive.Testing.csproj", "{73078FB5-6038-4674-B4C4-32FD81B88055}" EndProject @@ -36,35 +36,53 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{D324579D EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Facades", "Facades", "{A0F39260-B8F8-4FCB-9679-0ED917A22BDF}" ProjectSection(SolutionItems) = preProject - facades\Directory.build.props = facades\Directory.build.props facades\System.Reactive.Compatibility.nuspec = facades\System.Reactive.Compatibility.nuspec EndProjectSection EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Core", "facades\System.Reactive.Core\System.Reactive.Core.csproj", "{296C5140-7945-439D-B090-AB6250DEEE51}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Tests.System.Reactive.ApiApprovals", "tests\Tests.System.Reactive.ApiApprovals\Tests.System.Reactive.ApiApprovals.csproj", "{01CCDA6D-4D00-4DF2-82B0-359FD5E0CDC6}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Experimental", "facades\System.Reactive.Experimental\System.Reactive.Experimental.csproj", "{3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Benchmarks.System.Reactive", "benchmarks\Benchmarks.System.Reactive\Benchmarks.System.Reactive.csproj", "{5C7906F6-232E-455C-9269-68EF84F393C9}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Linq", "facades\System.Reactive.Linq\System.Reactive.Linq.csproj", "{68B8D2CD-BB8F-4033-90B0-C282304C2B2B}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Benchmarks", "Benchmarks", "{C8E480ED-B592-4341-A0C9-183E822EB6B9}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.PlatformServices", "facades\System.Reactive.PlatformServices\System.Reactive.PlatformServices.csproj", "{BA291C8D-1ECB-4C87-9C50-10474F3A15A5}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "V3", "V3", "{5B89DCA3-A1EA-4344-A693-17884642CEA2}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Providers", "facades\System.Reactive.Providers\System.Reactive.Providers.csproj", "{79C55CAE-E1B8-4808-9970-73D893627B99}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "V6", "V6", "{86913EFB-EAE1-4385-89C0-5729347EB6BF}" + ProjectSection(SolutionItems) = preProject + facades\V6\.editorconfig = facades\V6\.editorconfig + EndProjectSection EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Runtime.Remoting", "facades\System.Reactive.Runtime.Remoting\System.Reactive.Runtime.Remoting.csproj", "{D2303705-01E6-404E-9034-F9CCE502DF00}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Core", "facades\V3\System.Reactive.Core\System.Reactive.Core.csproj", "{B535A8B1-92D2-485C-B590-68ADFB252E67}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Windows.Forms", "facades\System.Reactive.Windows.Forms\System.Reactive.Windows.Forms.csproj", "{15585B53-9F85-4439-9D80-D827F1AD91E6}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Experimental", "facades\V3\System.Reactive.Experimental\System.Reactive.Experimental.csproj", "{8CC1BC1B-AC68-44B6-9F31-E73B47063C48}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Windows.Threading", "facades\System.Reactive.Windows.Threading\System.Reactive.Windows.Threading.csproj", "{4DCC120A-FD19-409B-A0E6-A049C4D0B663}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Interfaces", "facades\V3\System.Reactive.Interfaces\System.Reactive.Interfaces.csproj", "{2B6D0DD4-E441-41CA-9778-A83444FAAAC7}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.WindowsRuntime", "facades\System.Reactive.WindowsRuntime\System.Reactive.WindowsRuntime.csproj", "{E9BB350B-D4EF-42E1-B4E2-14058AC6809B}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Linq", "facades\V3\System.Reactive.Linq\System.Reactive.Linq.csproj", "{A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Interfaces", "facades\System.Reactive.Interfaces\System.Reactive.Interfaces.csproj", "{A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.PlatformServices", "facades\V3\System.Reactive.PlatformServices\System.Reactive.PlatformServices.csproj", "{BE867085-A69F-47AE-8996-28D23E56D16F}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Tests.System.Reactive.ApiApprovals", "tests\Tests.System.Reactive.ApiApprovals\Tests.System.Reactive.ApiApprovals.csproj", "{01CCDA6D-4D00-4DF2-82B0-359FD5E0CDC6}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Providers", "facades\V3\System.Reactive.Providers\System.Reactive.Providers.csproj", "{8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Benchmarks.System.Reactive", "benchmarks\Benchmarks.System.Reactive\Benchmarks.System.Reactive.csproj", "{5C7906F6-232E-455C-9269-68EF84F393C9}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Runtime.Remoting", "facades\V3\System.Reactive.Runtime.Remoting\System.Reactive.Runtime.Remoting.csproj", "{35F4F86C-CD4E-483D-95FC-1E30FB9483AC}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Benchmarks", "Benchmarks", "{C8E480ED-B592-4341-A0C9-183E822EB6B9}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Windows.Forms", "facades\V3\System.Reactive.Windows.Forms\System.Reactive.Windows.Forms.csproj", "{49D3AD83-512E-4072-92FE-3DEFFE2FA726}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Windows.Threading", "facades\V3\System.Reactive.Windows.Threading\System.Reactive.Windows.Threading.csproj", "{1CEFEE14-CB79-4365-AE52-CC5203A17B84}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.WindowsRuntime", "facades\V3\System.Reactive.WindowsRuntime\System.Reactive.WindowsRuntime.csproj", "{7ADC1A67-3AB8-4279-807A-3EB394377E1F}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive", "facades\V6\System.Reactive.Core\System.Reactive.csproj", "{30EA7BAB-A24E-42C1-BAD3-6F5032023E12}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "UiIntegration", "UiIntegration", "{5A07FCC2-734F-4F58-B4AD-F42495F8F2CC}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Integration.Uwp", "src\System.Reactive.Integration.Uwp\System.Reactive.Integration.Uwp.csproj", "{79825277-B81D-447A-BDE3-0096F4FCE7D6}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Integration.Wpf", "src\System.Reactive.Integration.Wpf\System.Reactive.Integration.Wpf.csproj", "{AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Integration.Windows.Runtime", "src\System.Reactive.Integration.Windows.Runtime\System.Reactive.Integration.Windows.Runtime.csproj", "{C235F7DA-4EF2-434D-A94E-77C17026EF00}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reactive.Integration.Windows.Forms", "src\System.Reactive.Integration.Windows.Forms\System.Reactive.Integration.Windows.Forms.csproj", "{E7C4AF16-460E-4397-8CDA-B71386143C55}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -164,166 +182,6 @@ Global {10CC7191-D936-46CA-BA87-0646733571EA}.Release|x86.ActiveCfg = Release|x86 {10CC7191-D936-46CA-BA87-0646733571EA}.Release|x86.Build.0 = Release|x86 {10CC7191-D936-46CA-BA87-0646733571EA}.Release|x86.Deploy.0 = Release|x86 - {296C5140-7945-439D-B090-AB6250DEEE51}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Debug|Any CPU.Build.0 = Debug|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Debug|ARM.ActiveCfg = Debug|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Debug|ARM.Build.0 = Debug|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Debug|x64.ActiveCfg = Debug|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Debug|x64.Build.0 = Debug|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Debug|x86.ActiveCfg = Debug|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Debug|x86.Build.0 = Debug|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Release|Any CPU.ActiveCfg = Release|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Release|Any CPU.Build.0 = Release|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Release|ARM.ActiveCfg = Release|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Release|ARM.Build.0 = Release|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Release|x64.ActiveCfg = Release|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Release|x64.Build.0 = Release|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Release|x86.ActiveCfg = Release|Any CPU - {296C5140-7945-439D-B090-AB6250DEEE51}.Release|x86.Build.0 = Release|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Debug|Any CPU.Build.0 = Debug|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Debug|ARM.ActiveCfg = Debug|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Debug|ARM.Build.0 = Debug|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Debug|x64.ActiveCfg = Debug|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Debug|x64.Build.0 = Debug|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Debug|x86.ActiveCfg = Debug|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Debug|x86.Build.0 = Debug|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Release|Any CPU.ActiveCfg = Release|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Release|Any CPU.Build.0 = Release|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Release|ARM.ActiveCfg = Release|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Release|ARM.Build.0 = Release|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Release|x64.ActiveCfg = Release|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Release|x64.Build.0 = Release|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Release|x86.ActiveCfg = Release|Any CPU - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82}.Release|x86.Build.0 = Release|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Debug|ARM.ActiveCfg = Debug|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Debug|ARM.Build.0 = Debug|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Debug|x64.ActiveCfg = Debug|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Debug|x64.Build.0 = Debug|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Debug|x86.ActiveCfg = Debug|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Debug|x86.Build.0 = Debug|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Release|Any CPU.Build.0 = Release|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Release|ARM.ActiveCfg = Release|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Release|ARM.Build.0 = Release|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Release|x64.ActiveCfg = Release|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Release|x64.Build.0 = Release|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Release|x86.ActiveCfg = Release|Any CPU - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B}.Release|x86.Build.0 = Release|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Debug|Any CPU.Build.0 = Debug|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Debug|ARM.ActiveCfg = Debug|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Debug|ARM.Build.0 = Debug|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Debug|x64.ActiveCfg = Debug|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Debug|x64.Build.0 = Debug|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Debug|x86.ActiveCfg = Debug|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Debug|x86.Build.0 = Debug|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Release|Any CPU.ActiveCfg = Release|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Release|Any CPU.Build.0 = Release|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Release|ARM.ActiveCfg = Release|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Release|ARM.Build.0 = Release|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Release|x64.ActiveCfg = Release|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Release|x64.Build.0 = Release|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Release|x86.ActiveCfg = Release|Any CPU - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5}.Release|x86.Build.0 = Release|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Debug|Any CPU.Build.0 = Debug|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Debug|ARM.ActiveCfg = Debug|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Debug|ARM.Build.0 = Debug|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Debug|x64.ActiveCfg = Debug|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Debug|x64.Build.0 = Debug|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Debug|x86.ActiveCfg = Debug|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Debug|x86.Build.0 = Debug|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Release|Any CPU.ActiveCfg = Release|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Release|Any CPU.Build.0 = Release|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Release|ARM.ActiveCfg = Release|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Release|ARM.Build.0 = Release|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Release|x64.ActiveCfg = Release|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Release|x64.Build.0 = Release|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Release|x86.ActiveCfg = Release|Any CPU - {79C55CAE-E1B8-4808-9970-73D893627B99}.Release|x86.Build.0 = Release|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Debug|ARM.ActiveCfg = Debug|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Debug|ARM.Build.0 = Debug|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Debug|x64.ActiveCfg = Debug|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Debug|x64.Build.0 = Debug|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Debug|x86.ActiveCfg = Debug|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Debug|x86.Build.0 = Debug|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Release|Any CPU.Build.0 = Release|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Release|ARM.ActiveCfg = Release|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Release|ARM.Build.0 = Release|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Release|x64.ActiveCfg = Release|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Release|x64.Build.0 = Release|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Release|x86.ActiveCfg = Release|Any CPU - {D2303705-01E6-404E-9034-F9CCE502DF00}.Release|x86.Build.0 = Release|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Debug|Any CPU.Build.0 = Debug|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Debug|ARM.ActiveCfg = Debug|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Debug|ARM.Build.0 = Debug|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Debug|x64.ActiveCfg = Debug|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Debug|x64.Build.0 = Debug|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Debug|x86.ActiveCfg = Debug|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Debug|x86.Build.0 = Debug|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Release|Any CPU.ActiveCfg = Release|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Release|Any CPU.Build.0 = Release|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Release|ARM.ActiveCfg = Release|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Release|ARM.Build.0 = Release|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Release|x64.ActiveCfg = Release|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Release|x64.Build.0 = Release|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Release|x86.ActiveCfg = Release|Any CPU - {15585B53-9F85-4439-9D80-D827F1AD91E6}.Release|x86.Build.0 = Release|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Debug|Any CPU.Build.0 = Debug|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Debug|ARM.ActiveCfg = Debug|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Debug|ARM.Build.0 = Debug|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Debug|x64.ActiveCfg = Debug|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Debug|x64.Build.0 = Debug|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Debug|x86.ActiveCfg = Debug|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Debug|x86.Build.0 = Debug|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Release|Any CPU.ActiveCfg = Release|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Release|Any CPU.Build.0 = Release|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Release|ARM.ActiveCfg = Release|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Release|ARM.Build.0 = Release|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Release|x64.ActiveCfg = Release|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Release|x64.Build.0 = Release|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Release|x86.ActiveCfg = Release|Any CPU - {4DCC120A-FD19-409B-A0E6-A049C4D0B663}.Release|x86.Build.0 = Release|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Debug|ARM.ActiveCfg = Debug|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Debug|ARM.Build.0 = Debug|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Debug|x64.ActiveCfg = Debug|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Debug|x64.Build.0 = Debug|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Debug|x86.ActiveCfg = Debug|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Debug|x86.Build.0 = Debug|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Release|Any CPU.Build.0 = Release|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Release|ARM.ActiveCfg = Release|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Release|ARM.Build.0 = Release|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Release|x64.ActiveCfg = Release|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Release|x64.Build.0 = Release|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Release|x86.ActiveCfg = Release|Any CPU - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B}.Release|x86.Build.0 = Release|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Debug|Any CPU.Build.0 = Debug|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Debug|ARM.ActiveCfg = Debug|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Debug|ARM.Build.0 = Debug|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Debug|x64.ActiveCfg = Debug|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Debug|x64.Build.0 = Debug|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Debug|x86.ActiveCfg = Debug|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Debug|x86.Build.0 = Debug|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Release|Any CPU.ActiveCfg = Release|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Release|Any CPU.Build.0 = Release|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Release|ARM.ActiveCfg = Release|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Release|ARM.Build.0 = Release|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Release|x64.ActiveCfg = Release|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Release|x64.Build.0 = Release|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Release|x86.ActiveCfg = Release|Any CPU - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6}.Release|x86.Build.0 = Release|Any CPU {01CCDA6D-4D00-4DF2-82B0-359FD5E0CDC6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {01CCDA6D-4D00-4DF2-82B0-359FD5E0CDC6}.Debug|Any CPU.Build.0 = Debug|Any CPU {01CCDA6D-4D00-4DF2-82B0-359FD5E0CDC6}.Debug|ARM.ActiveCfg = Debug|Any CPU @@ -356,6 +214,246 @@ Global {5C7906F6-232E-455C-9269-68EF84F393C9}.Release|x64.Build.0 = Rx.net 4.0|Any CPU {5C7906F6-232E-455C-9269-68EF84F393C9}.Release|x86.ActiveCfg = Rx.net 4.0|Any CPU {5C7906F6-232E-455C-9269-68EF84F393C9}.Release|x86.Build.0 = Rx.net 4.0|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Debug|ARM.ActiveCfg = Debug|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Debug|ARM.Build.0 = Debug|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Debug|x64.ActiveCfg = Debug|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Debug|x64.Build.0 = Debug|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Debug|x86.ActiveCfg = Debug|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Debug|x86.Build.0 = Debug|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Release|Any CPU.Build.0 = Release|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Release|ARM.ActiveCfg = Release|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Release|ARM.Build.0 = Release|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Release|x64.ActiveCfg = Release|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Release|x64.Build.0 = Release|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Release|x86.ActiveCfg = Release|Any CPU + {B535A8B1-92D2-485C-B590-68ADFB252E67}.Release|x86.Build.0 = Release|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Debug|ARM.ActiveCfg = Debug|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Debug|ARM.Build.0 = Debug|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Debug|x64.ActiveCfg = Debug|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Debug|x64.Build.0 = Debug|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Debug|x86.ActiveCfg = Debug|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Debug|x86.Build.0 = Debug|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Release|Any CPU.Build.0 = Release|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Release|ARM.ActiveCfg = Release|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Release|ARM.Build.0 = Release|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Release|x64.ActiveCfg = Release|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Release|x64.Build.0 = Release|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Release|x86.ActiveCfg = Release|Any CPU + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48}.Release|x86.Build.0 = Release|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Debug|ARM.ActiveCfg = Debug|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Debug|ARM.Build.0 = Debug|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Debug|x64.ActiveCfg = Debug|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Debug|x64.Build.0 = Debug|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Debug|x86.ActiveCfg = Debug|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Debug|x86.Build.0 = Debug|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Release|Any CPU.Build.0 = Release|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Release|ARM.ActiveCfg = Release|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Release|ARM.Build.0 = Release|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Release|x64.ActiveCfg = Release|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Release|x64.Build.0 = Release|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Release|x86.ActiveCfg = Release|Any CPU + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7}.Release|x86.Build.0 = Release|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Debug|ARM.ActiveCfg = Debug|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Debug|ARM.Build.0 = Debug|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Debug|x64.ActiveCfg = Debug|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Debug|x64.Build.0 = Debug|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Debug|x86.ActiveCfg = Debug|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Debug|x86.Build.0 = Debug|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Release|Any CPU.Build.0 = Release|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Release|ARM.ActiveCfg = Release|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Release|ARM.Build.0 = Release|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Release|x64.ActiveCfg = Release|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Release|x64.Build.0 = Release|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Release|x86.ActiveCfg = Release|Any CPU + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E}.Release|x86.Build.0 = Release|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Debug|ARM.ActiveCfg = Debug|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Debug|ARM.Build.0 = Debug|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Debug|x64.ActiveCfg = Debug|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Debug|x64.Build.0 = Debug|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Debug|x86.ActiveCfg = Debug|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Debug|x86.Build.0 = Debug|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Release|Any CPU.Build.0 = Release|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Release|ARM.ActiveCfg = Release|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Release|ARM.Build.0 = Release|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Release|x64.ActiveCfg = Release|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Release|x64.Build.0 = Release|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Release|x86.ActiveCfg = Release|Any CPU + {BE867085-A69F-47AE-8996-28D23E56D16F}.Release|x86.Build.0 = Release|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Debug|ARM.ActiveCfg = Debug|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Debug|ARM.Build.0 = Debug|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Debug|x64.ActiveCfg = Debug|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Debug|x64.Build.0 = Debug|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Debug|x86.ActiveCfg = Debug|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Debug|x86.Build.0 = Debug|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Release|Any CPU.Build.0 = Release|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Release|ARM.ActiveCfg = Release|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Release|ARM.Build.0 = Release|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Release|x64.ActiveCfg = Release|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Release|x64.Build.0 = Release|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Release|x86.ActiveCfg = Release|Any CPU + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D}.Release|x86.Build.0 = Release|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Debug|ARM.ActiveCfg = Debug|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Debug|ARM.Build.0 = Debug|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Debug|x64.ActiveCfg = Debug|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Debug|x64.Build.0 = Debug|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Debug|x86.ActiveCfg = Debug|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Debug|x86.Build.0 = Debug|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Release|Any CPU.Build.0 = Release|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Release|ARM.ActiveCfg = Release|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Release|ARM.Build.0 = Release|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Release|x64.ActiveCfg = Release|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Release|x64.Build.0 = Release|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Release|x86.ActiveCfg = Release|Any CPU + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC}.Release|x86.Build.0 = Release|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Debug|Any CPU.Build.0 = Debug|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Debug|ARM.ActiveCfg = Debug|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Debug|ARM.Build.0 = Debug|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Debug|x64.ActiveCfg = Debug|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Debug|x64.Build.0 = Debug|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Debug|x86.ActiveCfg = Debug|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Debug|x86.Build.0 = Debug|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Release|Any CPU.ActiveCfg = Release|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Release|Any CPU.Build.0 = Release|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Release|ARM.ActiveCfg = Release|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Release|ARM.Build.0 = Release|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Release|x64.ActiveCfg = Release|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Release|x64.Build.0 = Release|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Release|x86.ActiveCfg = Release|Any CPU + {49D3AD83-512E-4072-92FE-3DEFFE2FA726}.Release|x86.Build.0 = Release|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Debug|ARM.ActiveCfg = Debug|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Debug|ARM.Build.0 = Debug|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Debug|x64.ActiveCfg = Debug|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Debug|x64.Build.0 = Debug|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Debug|x86.ActiveCfg = Debug|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Debug|x86.Build.0 = Debug|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Release|Any CPU.Build.0 = Release|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Release|ARM.ActiveCfg = Release|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Release|ARM.Build.0 = Release|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Release|x64.ActiveCfg = Release|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Release|x64.Build.0 = Release|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Release|x86.ActiveCfg = Release|Any CPU + {1CEFEE14-CB79-4365-AE52-CC5203A17B84}.Release|x86.Build.0 = Release|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Debug|ARM.ActiveCfg = Debug|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Debug|ARM.Build.0 = Debug|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Debug|x64.ActiveCfg = Debug|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Debug|x64.Build.0 = Debug|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Debug|x86.ActiveCfg = Debug|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Debug|x86.Build.0 = Debug|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Release|Any CPU.Build.0 = Release|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Release|ARM.ActiveCfg = Release|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Release|ARM.Build.0 = Release|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Release|x64.ActiveCfg = Release|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Release|x64.Build.0 = Release|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Release|x86.ActiveCfg = Release|Any CPU + {7ADC1A67-3AB8-4279-807A-3EB394377E1F}.Release|x86.Build.0 = Release|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Debug|Any CPU.Build.0 = Debug|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Debug|ARM.ActiveCfg = Debug|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Debug|ARM.Build.0 = Debug|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Debug|x64.ActiveCfg = Debug|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Debug|x64.Build.0 = Debug|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Debug|x86.ActiveCfg = Debug|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Debug|x86.Build.0 = Debug|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Release|Any CPU.ActiveCfg = Release|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Release|Any CPU.Build.0 = Release|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Release|ARM.ActiveCfg = Release|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Release|ARM.Build.0 = Release|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Release|x64.ActiveCfg = Release|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Release|x64.Build.0 = Release|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Release|x86.ActiveCfg = Release|Any CPU + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12}.Release|x86.Build.0 = Release|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Debug|ARM.ActiveCfg = Debug|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Debug|ARM.Build.0 = Debug|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Debug|x64.ActiveCfg = Debug|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Debug|x64.Build.0 = Debug|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Debug|x86.ActiveCfg = Debug|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Debug|x86.Build.0 = Debug|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Release|Any CPU.ActiveCfg = Release|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Release|Any CPU.Build.0 = Release|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Release|ARM.ActiveCfg = Release|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Release|ARM.Build.0 = Release|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Release|x64.ActiveCfg = Release|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Release|x64.Build.0 = Release|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Release|x86.ActiveCfg = Release|Any CPU + {79825277-B81D-447A-BDE3-0096F4FCE7D6}.Release|x86.Build.0 = Release|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Debug|ARM.ActiveCfg = Debug|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Debug|ARM.Build.0 = Debug|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Debug|x64.ActiveCfg = Debug|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Debug|x64.Build.0 = Debug|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Debug|x86.ActiveCfg = Debug|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Debug|x86.Build.0 = Debug|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Release|Any CPU.Build.0 = Release|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Release|ARM.ActiveCfg = Release|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Release|ARM.Build.0 = Release|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Release|x64.ActiveCfg = Release|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Release|x64.Build.0 = Release|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Release|x86.ActiveCfg = Release|Any CPU + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8}.Release|x86.Build.0 = Release|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Debug|ARM.ActiveCfg = Debug|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Debug|ARM.Build.0 = Debug|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Debug|x64.ActiveCfg = Debug|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Debug|x64.Build.0 = Debug|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Debug|x86.ActiveCfg = Debug|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Debug|x86.Build.0 = Debug|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Release|Any CPU.Build.0 = Release|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Release|ARM.ActiveCfg = Release|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Release|ARM.Build.0 = Release|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Release|x64.ActiveCfg = Release|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Release|x64.Build.0 = Release|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Release|x86.ActiveCfg = Release|Any CPU + {C235F7DA-4EF2-434D-A94E-77C17026EF00}.Release|x86.Build.0 = Release|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Debug|ARM.ActiveCfg = Debug|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Debug|ARM.Build.0 = Debug|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Debug|x64.ActiveCfg = Debug|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Debug|x64.Build.0 = Debug|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Debug|x86.ActiveCfg = Debug|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Debug|x86.Build.0 = Debug|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Release|Any CPU.Build.0 = Release|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Release|ARM.ActiveCfg = Release|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Release|ARM.Build.0 = Release|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Release|x64.ActiveCfg = Release|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Release|x64.Build.0 = Release|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Release|x86.ActiveCfg = Release|Any CPU + {E7C4AF16-460E-4397-8CDA-B71386143C55}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -363,18 +461,25 @@ Global GlobalSection(NestedProjects) = preSolution {E072D663-A241-4FEC-B888-45640F69D9CE} = {D324579D-CBE6-4867-8980-D7842C7C45A2} {10CC7191-D936-46CA-BA87-0646733571EA} = {D324579D-CBE6-4867-8980-D7842C7C45A2} - {296C5140-7945-439D-B090-AB6250DEEE51} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} - {3EEB4F40-002A-4F72-9DDF-8E6FE3847B82} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} - {68B8D2CD-BB8F-4033-90B0-C282304C2B2B} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} - {BA291C8D-1ECB-4C87-9C50-10474F3A15A5} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} - {79C55CAE-E1B8-4808-9970-73D893627B99} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} - {D2303705-01E6-404E-9034-F9CCE502DF00} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} - {15585B53-9F85-4439-9D80-D827F1AD91E6} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} - {4DCC120A-FD19-409B-A0E6-A049C4D0B663} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} - {E9BB350B-D4EF-42E1-B4E2-14058AC6809B} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} - {A31DDC7E-E883-4DBD-8FB8-D7DFC56059F6} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} {01CCDA6D-4D00-4DF2-82B0-359FD5E0CDC6} = {D324579D-CBE6-4867-8980-D7842C7C45A2} {5C7906F6-232E-455C-9269-68EF84F393C9} = {C8E480ED-B592-4341-A0C9-183E822EB6B9} + {5B89DCA3-A1EA-4344-A693-17884642CEA2} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} + {86913EFB-EAE1-4385-89C0-5729347EB6BF} = {A0F39260-B8F8-4FCB-9679-0ED917A22BDF} + {B535A8B1-92D2-485C-B590-68ADFB252E67} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {8CC1BC1B-AC68-44B6-9F31-E73B47063C48} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {2B6D0DD4-E441-41CA-9778-A83444FAAAC7} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {A1A6D894-C9BF-4E75-9FCE-3EB2E38EA58E} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {BE867085-A69F-47AE-8996-28D23E56D16F} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {8BD104A5-5EDB-4E5E-A9E8-FECCB78E0A2D} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {35F4F86C-CD4E-483D-95FC-1E30FB9483AC} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {49D3AD83-512E-4072-92FE-3DEFFE2FA726} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {1CEFEE14-CB79-4365-AE52-CC5203A17B84} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {7ADC1A67-3AB8-4279-807A-3EB394377E1F} = {5B89DCA3-A1EA-4344-A693-17884642CEA2} + {30EA7BAB-A24E-42C1-BAD3-6F5032023E12} = {86913EFB-EAE1-4385-89C0-5729347EB6BF} + {79825277-B81D-447A-BDE3-0096F4FCE7D6} = {5A07FCC2-734F-4F58-B4AD-F42495F8F2CC} + {AE6FC45F-B76F-41B4-993E-9B5BBED2CEA8} = {5A07FCC2-734F-4F58-B4AD-F42495F8F2CC} + {C235F7DA-4EF2-434D-A94E-77C17026EF00} = {5A07FCC2-734F-4F58-B4AD-F42495F8F2CC} + {E7C4AF16-460E-4397-8CDA-B71386143C55} = {5A07FCC2-734F-4F58-B4AD-F42495F8F2CC} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {2483F58F-A8D6-4FFE-A3C1-10F3A36DBE69} diff --git a/Rx.NET/Source/facades/Directory.build.targets b/Rx.NET/Source/facades/Directory.build.targets deleted file mode 100644 index 92c4bd8cc..000000000 --- a/Rx.NET/Source/facades/Directory.build.targets +++ /dev/null @@ -1,3 +0,0 @@ - - - \ No newline at end of file diff --git a/Rx.NET/Source/facades/GlobalAssemblyVersion.cs b/Rx.NET/Source/facades/GlobalAssemblyVersion.cs deleted file mode 100644 index 605e18140..000000000 --- a/Rx.NET/Source/facades/GlobalAssemblyVersion.cs +++ /dev/null @@ -1,16 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT License. -// See the LICENSE file in the project root for more information. - - -using System.Reflection; - - -#if WINDOWS_UWP -[assembly: AssemblyVersion("3.0.4000.0")] -#elif NET472 || NETSTANDARD2_0 -[assembly: AssemblyVersion("3.0.6000.0")] -#else // this is here to prevent the build system from complaining. It should never be hit -[assembly: AssemblyVersion("invalid")] -#endif - diff --git a/Rx.NET/Source/facades/NuGet.Facades.Readme.md b/Rx.NET/Source/facades/NuGet.Facades.Readme.md index e358c724d..97dc6deab 100644 --- a/Rx.NET/Source/facades/NuGet.Facades.Readme.md +++ b/Rx.NET/Source/facades/NuGet.Facades.Readme.md @@ -1,5 +1,5 @@ -# Legacy facade package for `System.Reactive` +# Legacy facade package for `System.Reactive.Main` This package exists for backwards compatibility, and should not be used by new applications. Older versions of the Reactive Extensions for .NET (Rx) split types across various packages including this one. -Most applications using Rx today should reference `System.Reactive` directly. \ No newline at end of file +Most applications using Rx today should reference `System.Reactive.Main` directly. \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Core/System.Reactive.Core.csproj b/Rx.NET/Source/facades/System.Reactive.Core/System.Reactive.Core.csproj deleted file mode 100644 index 2da96f58f..000000000 --- a/Rx.NET/Source/facades/System.Reactive.Core/System.Reactive.Core.csproj +++ /dev/null @@ -1,20 +0,0 @@ - - - - net472;netstandard2.0;uap10.0.18362 - - - - Legacy facade for Reactive Extensions (Rx) for .NET - readme.md - - - - - - - - - - - \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Interfaces/System.Reactive.Interfaces.csproj b/Rx.NET/Source/facades/System.Reactive.Interfaces/System.Reactive.Interfaces.csproj deleted file mode 100644 index 2da96f58f..000000000 --- a/Rx.NET/Source/facades/System.Reactive.Interfaces/System.Reactive.Interfaces.csproj +++ /dev/null @@ -1,20 +0,0 @@ - - - - net472;netstandard2.0;uap10.0.18362 - - - - Legacy facade for Reactive Extensions (Rx) for .NET - readme.md - - - - - - - - - - - \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Linq/System.Reactive.Linq.csproj b/Rx.NET/Source/facades/System.Reactive.Linq/System.Reactive.Linq.csproj deleted file mode 100644 index 2da96f58f..000000000 --- a/Rx.NET/Source/facades/System.Reactive.Linq/System.Reactive.Linq.csproj +++ /dev/null @@ -1,20 +0,0 @@ - - - - net472;netstandard2.0;uap10.0.18362 - - - - Legacy facade for Reactive Extensions (Rx) for .NET - readme.md - - - - - - - - - - - \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.PlatformServices/System.Reactive.PlatformServices.csproj b/Rx.NET/Source/facades/System.Reactive.PlatformServices/System.Reactive.PlatformServices.csproj deleted file mode 100644 index 2da96f58f..000000000 --- a/Rx.NET/Source/facades/System.Reactive.PlatformServices/System.Reactive.PlatformServices.csproj +++ /dev/null @@ -1,20 +0,0 @@ - - - - net472;netstandard2.0;uap10.0.18362 - - - - Legacy facade for Reactive Extensions (Rx) for .NET - readme.md - - - - - - - - - - - \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Providers/System.Reactive.Providers.csproj b/Rx.NET/Source/facades/System.Reactive.Providers/System.Reactive.Providers.csproj deleted file mode 100644 index 2da96f58f..000000000 --- a/Rx.NET/Source/facades/System.Reactive.Providers/System.Reactive.Providers.csproj +++ /dev/null @@ -1,20 +0,0 @@ - - - - net472;netstandard2.0;uap10.0.18362 - - - - Legacy facade for Reactive Extensions (Rx) for .NET - readme.md - - - - - - - - - - - \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Runtime.Remoting/TypeForwarders.Remoting.cs b/Rx.NET/Source/facades/System.Reactive.Runtime.Remoting/TypeForwarders.Remoting.cs deleted file mode 100644 index 0fd4ae5ba..000000000 --- a/Rx.NET/Source/facades/System.Reactive.Runtime.Remoting/TypeForwarders.Remoting.cs +++ /dev/null @@ -1,5 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT License. -// See the LICENSE file in the project root for more information. - -[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.RemotingObservable))] diff --git a/Rx.NET/Source/facades/Directory.build.props b/Rx.NET/Source/facades/V3/Directory.build.props similarity index 90% rename from Rx.NET/Source/facades/Directory.build.props rename to Rx.NET/Source/facades/V3/Directory.build.props index 9b4f5df84..0017630b1 100644 --- a/Rx.NET/Source/facades/Directory.build.props +++ b/Rx.NET/Source/facades/V3/Directory.build.props @@ -1,5 +1,5 @@ - + false false diff --git a/Rx.NET/Source/facades/V3/Directory.build.targets b/Rx.NET/Source/facades/V3/Directory.build.targets new file mode 100644 index 000000000..b11f7934c --- /dev/null +++ b/Rx.NET/Source/facades/V3/Directory.build.targets @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/Rx.NET/Source/facades/V3/GlobalAssemblyVersion.cs b/Rx.NET/Source/facades/V3/GlobalAssemblyVersion.cs new file mode 100644 index 000000000..ae8085fa0 --- /dev/null +++ b/Rx.NET/Source/facades/V3/GlobalAssemblyVersion.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + + +using System.Reflection; + +// TODO: should these packages continue to have V3.0.x.0 version numbers? +// I had wanted to remove the uap10 targets from most of these, and switch back from +// MSBuild.Sdk.Extras to Microsoft.NET.Sdk, but if these are going to continue to +// claim to be V3.0 that might cause problems. +// I suppose the questions are: +// * who do we expect still to be using these packages? +// * what do we want them to get? +// These packages became nothing more than legacy facades in Rx 4.0 (shipped May 2018). +// In the 6 months since Rx 6.0 shipped, System.Reactive has had 2,043,585 downloads, +// while the System.Reactive.Linq package (which nobody should be using) has had +// 270,216 downloads! For a package nobody is meant to be using, it remains remarkably +// popular. +// So apparently people are taking dependencies on this and are ending up with the +// current version. So whatever it is they are doing today we need that to continue +// to work. +// What would go wrong if we trimmed this down to netstandard2.0 and net6.0, the same +// targets as System.Reactive.Base itself now supports? +// Perhaps what we need to do for all of these facades is ask the following question: +// Do any of the forwarded types have a different API surface area in different target? +// If no, then there should be absolutely no problem with just targetting the same as +// System.Reactive.Base. (In theory, the only problematic case would be the UWP version +// of ThreadPoolScheduler, which we've already decided to break backwards compatibility +// on as a special case, because that one on its own prevents everything else from +// moving forwards otherwise.) + + +#if WINDOWS_UWP +[assembly: AssemblyVersion("3.0.4000.0")] +#elif NET472 || NETSTANDARD2_0 +[assembly: AssemblyVersion("3.0.6000.0")] +#else // this is here to prevent the build system from complaining. It should never be hit +[assembly: AssemblyVersion("invalid")] +#endif + diff --git a/Rx.NET/Source/facades/System.Reactive.Compatibility.nuspec b/Rx.NET/Source/facades/V3/System.Reactive.Compatibility.nuspec similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.Compatibility.nuspec rename to Rx.NET/Source/facades/V3/System.Reactive.Compatibility.nuspec diff --git a/Rx.NET/Source/facades/V3/System.Reactive.Core/System.Reactive.Core.csproj b/Rx.NET/Source/facades/V3/System.Reactive.Core/System.Reactive.Core.csproj new file mode 100644 index 000000000..ced9ac5e2 --- /dev/null +++ b/Rx.NET/Source/facades/V3/System.Reactive.Core/System.Reactive.Core.csproj @@ -0,0 +1,20 @@ + + + + netstandard2.0 + + + + Legacy facade for Reactive Extensions (Rx) for .NET + readme.md + + + + + + + + + + + \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Core/TypeForwarders.Core.cs b/Rx.NET/Source/facades/V3/System.Reactive.Core/TypeForwarders.Core.cs similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.Core/TypeForwarders.Core.cs rename to Rx.NET/Source/facades/V3/System.Reactive.Core/TypeForwarders.Core.cs diff --git a/Rx.NET/Source/facades/System.Reactive.Experimental/System.Reactive.Experimental.csproj b/Rx.NET/Source/facades/V3/System.Reactive.Experimental/System.Reactive.Experimental.csproj similarity index 66% rename from Rx.NET/Source/facades/System.Reactive.Experimental/System.Reactive.Experimental.csproj rename to Rx.NET/Source/facades/V3/System.Reactive.Experimental/System.Reactive.Experimental.csproj index ac2d9f9a8..311bc08f0 100644 --- a/Rx.NET/Source/facades/System.Reactive.Experimental/System.Reactive.Experimental.csproj +++ b/Rx.NET/Source/facades/V3/System.Reactive.Experimental/System.Reactive.Experimental.csproj @@ -10,11 +10,11 @@ - + - + \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Experimental/TypeForwarders.Experimental.cs b/Rx.NET/Source/facades/V3/System.Reactive.Experimental/TypeForwarders.Experimental.cs similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.Experimental/TypeForwarders.Experimental.cs rename to Rx.NET/Source/facades/V3/System.Reactive.Experimental/TypeForwarders.Experimental.cs diff --git a/Rx.NET/Source/facades/V3/System.Reactive.Interfaces/System.Reactive.Interfaces.csproj b/Rx.NET/Source/facades/V3/System.Reactive.Interfaces/System.Reactive.Interfaces.csproj new file mode 100644 index 000000000..724df5a6e --- /dev/null +++ b/Rx.NET/Source/facades/V3/System.Reactive.Interfaces/System.Reactive.Interfaces.csproj @@ -0,0 +1,20 @@ + + + + netstandard2.0 + + + + Legacy facade for Reactive Extensions (Rx) for .NET + readme.md + + + + + + + + + + + \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Interfaces/TypeForwarders.Interfaces.cs b/Rx.NET/Source/facades/V3/System.Reactive.Interfaces/TypeForwarders.Interfaces.cs similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.Interfaces/TypeForwarders.Interfaces.cs rename to Rx.NET/Source/facades/V3/System.Reactive.Interfaces/TypeForwarders.Interfaces.cs diff --git a/Rx.NET/Source/facades/System.Reactive.Windows.Threading/System.Reactive.Windows.Threading.csproj b/Rx.NET/Source/facades/V3/System.Reactive.Linq/System.Reactive.Linq.csproj similarity index 50% rename from Rx.NET/Source/facades/System.Reactive.Windows.Threading/System.Reactive.Windows.Threading.csproj rename to Rx.NET/Source/facades/V3/System.Reactive.Linq/System.Reactive.Linq.csproj index 583c8ac48..f111c1619 100644 --- a/Rx.NET/Source/facades/System.Reactive.Windows.Threading/System.Reactive.Windows.Threading.csproj +++ b/Rx.NET/Source/facades/V3/System.Reactive.Linq/System.Reactive.Linq.csproj @@ -1,7 +1,7 @@ - + - net472;uap10.0.18362 + netstandard2.0 @@ -10,11 +10,11 @@ - + - + - + \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Linq/TypeForwarders.Linq.cs b/Rx.NET/Source/facades/V3/System.Reactive.Linq/TypeForwarders.Linq.cs similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.Linq/TypeForwarders.Linq.cs rename to Rx.NET/Source/facades/V3/System.Reactive.Linq/TypeForwarders.Linq.cs diff --git a/Rx.NET/Source/facades/V3/System.Reactive.PlatformServices/System.Reactive.PlatformServices.csproj b/Rx.NET/Source/facades/V3/System.Reactive.PlatformServices/System.Reactive.PlatformServices.csproj new file mode 100644 index 000000000..e3c9e9f4c --- /dev/null +++ b/Rx.NET/Source/facades/V3/System.Reactive.PlatformServices/System.Reactive.PlatformServices.csproj @@ -0,0 +1,21 @@ + + + + + netstandard2.0 + + + + Legacy facade for Reactive Extensions (Rx) for .NET + readme.md + + + + + + + + + + + \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.PlatformServices/TypeForwarders.PlatformServices.cs b/Rx.NET/Source/facades/V3/System.Reactive.PlatformServices/TypeForwarders.PlatformServices.cs similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.PlatformServices/TypeForwarders.PlatformServices.cs rename to Rx.NET/Source/facades/V3/System.Reactive.PlatformServices/TypeForwarders.PlatformServices.cs diff --git a/Rx.NET/Source/facades/V3/System.Reactive.Providers/System.Reactive.Providers.csproj b/Rx.NET/Source/facades/V3/System.Reactive.Providers/System.Reactive.Providers.csproj new file mode 100644 index 000000000..724df5a6e --- /dev/null +++ b/Rx.NET/Source/facades/V3/System.Reactive.Providers/System.Reactive.Providers.csproj @@ -0,0 +1,20 @@ + + + + netstandard2.0 + + + + Legacy facade for Reactive Extensions (Rx) for .NET + readme.md + + + + + + + + + + + \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Providers/TypeForwarders.Providers.cs b/Rx.NET/Source/facades/V3/System.Reactive.Providers/TypeForwarders.Providers.cs similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.Providers/TypeForwarders.Providers.cs rename to Rx.NET/Source/facades/V3/System.Reactive.Providers/TypeForwarders.Providers.cs diff --git a/Rx.NET/Source/facades/System.Reactive.Runtime.Remoting/System.Reactive.Runtime.Remoting.csproj b/Rx.NET/Source/facades/V3/System.Reactive.Runtime.Remoting/System.Reactive.Runtime.Remoting.csproj similarity index 67% rename from Rx.NET/Source/facades/System.Reactive.Runtime.Remoting/System.Reactive.Runtime.Remoting.csproj rename to Rx.NET/Source/facades/V3/System.Reactive.Runtime.Remoting/System.Reactive.Runtime.Remoting.csproj index 9cc9b36b9..de5526ef6 100644 --- a/Rx.NET/Source/facades/System.Reactive.Runtime.Remoting/System.Reactive.Runtime.Remoting.csproj +++ b/Rx.NET/Source/facades/V3/System.Reactive.Runtime.Remoting/System.Reactive.Runtime.Remoting.csproj @@ -10,11 +10,11 @@ - + - + \ No newline at end of file diff --git a/Rx.NET/Source/facades/V3/System.Reactive.Runtime.Remoting/TypeForwarders.Remoting.cs b/Rx.NET/Source/facades/V3/System.Reactive.Runtime.Remoting/TypeForwarders.Remoting.cs new file mode 100644 index 000000000..8354f0bd8 --- /dev/null +++ b/Rx.NET/Source/facades/V3/System.Reactive.Runtime.Remoting/TypeForwarders.Remoting.cs @@ -0,0 +1,10 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +// TODO: should we: +// 1. Move this type back out into this assembly, reinstating this as a proper package, not a facade +// 2. Add a new System.Reactive.Integration.Remoting for this. +// 3. Leave it in the V6 System.Reactive facade, since that's where existing dependents will already expect it to be. +// (Currently on 3.) +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.RemotingObservable))] diff --git a/Rx.NET/Source/facades/System.Reactive.Windows.Forms/System.Reactive.Windows.Forms.csproj b/Rx.NET/Source/facades/V3/System.Reactive.Windows.Forms/System.Reactive.Windows.Forms.csproj similarity index 61% rename from Rx.NET/Source/facades/System.Reactive.Windows.Forms/System.Reactive.Windows.Forms.csproj rename to Rx.NET/Source/facades/V3/System.Reactive.Windows.Forms/System.Reactive.Windows.Forms.csproj index ac2d9f9a8..7fb8e638c 100644 --- a/Rx.NET/Source/facades/System.Reactive.Windows.Forms/System.Reactive.Windows.Forms.csproj +++ b/Rx.NET/Source/facades/V3/System.Reactive.Windows.Forms/System.Reactive.Windows.Forms.csproj @@ -10,11 +10,11 @@ - + - + \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Windows.Forms/TypeForwarders.Forms.cs b/Rx.NET/Source/facades/V3/System.Reactive.Windows.Forms/TypeForwarders.Forms.cs similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.Windows.Forms/TypeForwarders.Forms.cs rename to Rx.NET/Source/facades/V3/System.Reactive.Windows.Forms/TypeForwarders.Forms.cs diff --git a/Rx.NET/Source/facades/V3/System.Reactive.Windows.Threading/System.Reactive.Windows.Threading.csproj b/Rx.NET/Source/facades/V3/System.Reactive.Windows.Threading/System.Reactive.Windows.Threading.csproj new file mode 100644 index 000000000..b867f6205 --- /dev/null +++ b/Rx.NET/Source/facades/V3/System.Reactive.Windows.Threading/System.Reactive.Windows.Threading.csproj @@ -0,0 +1,28 @@ + + + + net472;uap10.0.18362 + + + + Legacy facade for Reactive Extensions (Rx) for .NET + readme.md + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.Windows.Threading/TypeForwarders.Threading.cs b/Rx.NET/Source/facades/V3/System.Reactive.Windows.Threading/TypeForwarders.Threading.cs similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.Windows.Threading/TypeForwarders.Threading.cs rename to Rx.NET/Source/facades/V3/System.Reactive.Windows.Threading/TypeForwarders.Threading.cs diff --git a/Rx.NET/Source/facades/System.Reactive.WindowsRuntime/System.Reactive.WindowsRuntime.csproj b/Rx.NET/Source/facades/V3/System.Reactive.WindowsRuntime/System.Reactive.WindowsRuntime.csproj similarity index 64% rename from Rx.NET/Source/facades/System.Reactive.WindowsRuntime/System.Reactive.WindowsRuntime.csproj rename to Rx.NET/Source/facades/V3/System.Reactive.WindowsRuntime/System.Reactive.WindowsRuntime.csproj index 870c37999..cd9316bdc 100644 --- a/Rx.NET/Source/facades/System.Reactive.WindowsRuntime/System.Reactive.WindowsRuntime.csproj +++ b/Rx.NET/Source/facades/V3/System.Reactive.WindowsRuntime/System.Reactive.WindowsRuntime.csproj @@ -10,11 +10,11 @@ - + - + \ No newline at end of file diff --git a/Rx.NET/Source/facades/System.Reactive.WindowsRuntime/TypeForwarders.WindowsRuntime.cs b/Rx.NET/Source/facades/V3/System.Reactive.WindowsRuntime/TypeForwarders.WindowsRuntime.cs similarity index 100% rename from Rx.NET/Source/facades/System.Reactive.WindowsRuntime/TypeForwarders.WindowsRuntime.cs rename to Rx.NET/Source/facades/V3/System.Reactive.WindowsRuntime/TypeForwarders.WindowsRuntime.cs diff --git a/Rx.NET/Source/facades/V6/.editorconfig b/Rx.NET/Source/facades/V6/.editorconfig new file mode 100644 index 000000000..e3dfee7e3 --- /dev/null +++ b/Rx.NET/Source/facades/V6/.editorconfig @@ -0,0 +1,3 @@ +[*.cs] +# TODO: if RemotingObservable moves out of the System.Reactive facade, this will no longer be necessary +dotnet_remove_unnecessary_suppression_exclusions = CA1704 diff --git a/Rx.NET/Source/facades/V6/System.Reactive.Core/Placeholder.cs b/Rx.NET/Source/facades/V6/System.Reactive.Core/Placeholder.cs new file mode 100644 index 000000000..596305940 --- /dev/null +++ b/Rx.NET/Source/facades/V6/System.Reactive.Core/Placeholder.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +using System.Runtime.CompilerServices; + +[assembly:InternalsVisibleTo("Tests.System.Reactive.ApiApprovals, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] + +namespace System.Reactive +{ + /// + /// A type so that we can have at least one non-forwarded type in this assembly. + /// This is because the API Approval tests seem to do something quite odd with + /// assembly references, meaning that unless we actually retrieve a real type + /// object from the assembly we want to inspect, it won't be available. + /// + internal class Placeholder + { + } +} diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/Observable.Remoting.cs b/Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/Linq/Observable.Remoting.cs similarity index 99% rename from Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/Observable.Remoting.cs rename to Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/Linq/Observable.Remoting.cs index 9b2f40e2f..c6e8be150 100644 --- a/Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/Observable.Remoting.cs +++ b/Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/Linq/Observable.Remoting.cs @@ -97,7 +97,6 @@ public static IQbservable Remotable(this IQbservable Expression.Call( null, ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), -#pragma warning restore IL2060 source.Expression, Expression.Constant(lease, typeof(ILease)) ) diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/QueryLanguage.Remoting.cs b/Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/Linq/QueryLanguage.Remoting.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/QueryLanguage.Remoting.cs rename to Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/Linq/QueryLanguage.Remoting.cs diff --git a/Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/TypeForwarders.WindowsForms.cs b/Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/TypeForwarders.WindowsForms.cs new file mode 100644 index 000000000..b5c0cf03b --- /dev/null +++ b/Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/TypeForwarders.WindowsForms.cs @@ -0,0 +1,6 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.ControlScheduler))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.ControlObservable))] diff --git a/Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/TypeForwarders.Wpf.cs b/Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/TypeForwarders.Wpf.cs new file mode 100644 index 000000000..aa436d673 --- /dev/null +++ b/Rx.NET/Source/facades/V6/System.Reactive.Core/Platforms/Desktop/TypeForwarders.Wpf.cs @@ -0,0 +1,6 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.DispatcherScheduler))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.DispatcherObservable))] diff --git a/Rx.NET/Source/facades/V6/System.Reactive.Core/System.Reactive.csproj b/Rx.NET/Source/facades/V6/System.Reactive.Core/System.Reactive.csproj new file mode 100644 index 000000000..064e42075 --- /dev/null +++ b/Rx.NET/Source/facades/V6/System.Reactive.Core/System.Reactive.csproj @@ -0,0 +1,125 @@ + + + + netstandard2.0;net472;uap10.0.18362;net6.0;net6.0-windows10.0.19041 + + + + Legacy facade for Reactive Extensions (Rx) for .NET + readme.md + + + + + + + + + true + true + + + enable + + + + + + + + + TextTemplatingFileGenerator + QbservableEx.NAry.cs + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TextTemplatingFileGenerator + QbservableEx.NAry.cs + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Rx.NET/Source/facades/V6/System.Reactive.Core/TypeForwarders.Core.cs b/Rx.NET/Source/facades/V6/System.Reactive.Core/TypeForwarders.Core.cs new file mode 100644 index 000000000..f1bbfc83d --- /dev/null +++ b/Rx.NET/Source/facades/V6/System.Reactive.Core/TypeForwarders.Core.cs @@ -0,0 +1,146 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.ObservableExtensions))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.AnonymousObservable<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.AnonymousObserver<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.EventPatternSourceBase<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.EventPattern<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.EventPattern<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.ExperimentalAttribute))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.IEventPatternSource<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.IEventPattern<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.IEventSource<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.IObserver<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.ITaskObservableAwaiter<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.ITaskObservable<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.ListObservable<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Notification))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.NotificationKind))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Notification<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.ObservableBase<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Observer))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.ObserverBase<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.TimeInterval<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Timestamped))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Timestamped<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Unit))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.AsyncLock))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.CurrentThreadScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.DefaultScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.IConcurrencyAbstractionLayer))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.ImmediateScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.IScheduledItem<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.IScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.ISchedulerLongRunning))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.ISchedulerPeriodic))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.IStopwatch))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.IStopwatchProvider))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.LocalScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.EventLoopScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.HistoricalScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.HistoricalSchedulerBase))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.NewThreadScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.ScheduledItem<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.ScheduledItem<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.Scheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.SchedulerOperation))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.SchedulerOperationAwaiter))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.SchedulerQueue<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.Synchronization))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.SynchronizationContextScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.TaskObservationOptions))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.TaskPoolScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.ThreadPoolScheduler))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.VirtualTimeSchedulerBase<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.VirtualTimeSchedulerExtensions))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Concurrency.VirtualTimeScheduler<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.BooleanDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.CancellationDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.CompositeDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.ContextDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.Disposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.ICancelable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.MultipleAssignmentDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.RefCountDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.ScheduledDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.SerialDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.SingleAssignmentDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.SingleAssignmentDisposableValue))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Disposables.StableCompositeDisposable))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Pattern<,,,,,,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.Plan<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,,,,,,,,,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePattern<,,,,,,,,,,,,,,,>))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Joins.QueryablePlan<>))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.IGroupedObservable<,>))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.IQbservable))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.IQbservableProvider))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.IQbservable<>))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.LocalQueryMethodImplementationTypeAttribute))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.Observable))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.ObservableEx))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.Qbservable))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.QbservableEx))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.QueryDebugger))] +// TODO: where should this live? +//#if HAS_REMOTING +//[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Linq.RemotingObservable))] +//#endif +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.CurrentPlatformEnlightenmentProvider))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.DefaultSystemClock))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.EnlightenmentProvider))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.HostLifecycleService))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.HostResumingEventArgs))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.HostSuspendingEventArgs))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.IExceptionServices))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.IHostLifecycleNotifications))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.INotifySystemClockChanged))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.IPlatformEnlightenmentProvider))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.ISystemClock))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.PeriodicTimerSystemClockMonitor))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.PlatformEnlightenmentProvider))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.SystemClock))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.PlatformServices.SystemClockChangedEventArgs))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Subjects.AsyncSubject<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Subjects.BehaviorSubject<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Subjects.IConnectableObservable<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Subjects.ISubject<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Subjects.ISubject<,>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Subjects.ReplaySubject<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Subjects.Subject))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Subjects.SubjectBase<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Subjects.Subject<>))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reactive.Threading.Tasks.TaskObservableExtensions))] +[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.CompilerServices.TaskObservableMethodBuilder<>))] diff --git a/Rx.NET/Source/src/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.csproj b/Rx.NET/Source/src/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.csproj index 962108769..cae0a851c 100644 --- a/Rx.NET/Source/src/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.csproj +++ b/Rx.NET/Source/src/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.csproj @@ -1,6 +1,6 @@ - + - netstandard2.0;net472;uap10.0.18362;net6.0 + netstandard2.0 false Reactive Extensions Testing Library containing interfaces and classes providing functionality to test applications and libraries built using Reactive Extensions. Microsoft.Reactive.Testing - Testing Helper Library @@ -19,7 +19,7 @@ - + diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Concurrency/CoreDispatcherScheduler.cs b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Concurrency/CoreDispatcherScheduler.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/UWP/Concurrency/CoreDispatcherScheduler.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Uwp/Concurrency/CoreDispatcherScheduler.cs diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/EventPatternSource.cs b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/EventPatternSource.cs similarity index 84% rename from Rx.NET/Source/src/System.Reactive/Platforms/UWP/EventPatternSource.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Uwp/EventPatternSource.cs index 409a4abf8..563cdfea8 100644 --- a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/EventPatternSource.cs +++ b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/EventPatternSource.cs @@ -7,7 +7,7 @@ namespace System.Reactive { - internal class EventPatternSource : EventPatternSourceBase, IEventPatternSource + internal sealed class EventPatternSource : EventPatternSourceBase, IEventPatternSource { public EventPatternSource(IObservable> source, Action, /*object,*/ EventPattern> invokeHandler) : base(source, invokeHandler) diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/IEventPatternSource.cs b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/IEventPatternSource.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/UWP/IEventPatternSource.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Uwp/IEventPatternSource.cs diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/AsyncInfoObservable.cs b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Linq/AsyncInfoObservable.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/AsyncInfoObservable.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Uwp/Linq/AsyncInfoObservable.cs diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/CoreDispatcherObservable.cs b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Linq/CoreDispatcherObservable.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/CoreDispatcherObservable.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Uwp/Linq/CoreDispatcherObservable.cs diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/WindowsObservable.Events.cs b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Linq/WindowsObservable.Events.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/WindowsObservable.Events.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Uwp/Linq/WindowsObservable.Events.cs diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/WindowsObservable.StandardSequenceOperators.cs b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Linq/WindowsObservable.StandardSequenceOperators.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/WindowsObservable.StandardSequenceOperators.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Uwp/Linq/WindowsObservable.StandardSequenceOperators.cs diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/Windows/Strings_WindowsThreading.Designer.cs b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Strings_WindowsThreading.Designer.cs similarity index 72% rename from Rx.NET/Source/src/System.Reactive/Platforms/Windows/Strings_WindowsThreading.Designer.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Uwp/Strings_WindowsThreading.Designer.cs index 57ea8c5a8..0036bddc8 100644 --- a/Rx.NET/Source/src/System.Reactive/Platforms/Windows/Strings_WindowsThreading.Designer.cs +++ b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Strings_WindowsThreading.Designer.cs @@ -8,11 +8,11 @@ // //------------------------------------------------------------------------------ -namespace System.Reactive -{ +namespace System.Reactive { + using System; using System.Reflection; - - + + /// /// A strongly-typed resource class, for looking up localized strings, etc. /// @@ -20,73 +20,52 @@ namespace System.Reactive // class via a tool like ResGen or Visual Studio. // To add or remove a member, edit your .ResX file then rerun ResGen // with the /str option, or rebuild your VS project. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] - internal class Strings_WindowsThreading - { - + internal class Strings_WindowsThreading { + private static global::System.Resources.ResourceManager resourceMan; - + private static global::System.Globalization.CultureInfo resourceCulture; - + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] - internal Strings_WindowsThreading() - { + internal Strings_WindowsThreading() { } - + /// /// Returns the cached ResourceManager instance used by this class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Resources.ResourceManager ResourceManager - { - get - { - if (object.ReferenceEquals(resourceMan, null)) - { - global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Platforms.Windows.Strings_WindowsThreading", typeof(Strings_WindowsThreading).GetTypeInfo().Assembly); + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_WindowsThreading", typeof(Strings_WindowsThreading).GetTypeInfo().Assembly); resourceMan = temp; } return resourceMan; } } - + /// /// Overrides the current thread's CurrentUICulture property for all /// resource lookups using this strongly typed resource class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Globalization.CultureInfo Culture - { - get - { + internal static global::System.Globalization.CultureInfo Culture { + get { return resourceCulture; } - set - { + set { resourceCulture = value; } } - - /// - /// Looks up a localized string similar to The current thread has no Dispatcher associated with it.. - /// - internal static string NO_DISPATCHER_CURRENT_THREAD - { - get - { - return ResourceManager.GetString("NO_DISPATCHER_CURRENT_THREAD", resourceCulture); - } - } - + /// /// Looks up a localized string similar to No current Window object found to obtain a CoreDispatcher from.. /// - internal static string NO_WINDOW_CURRENT - { - get - { + internal static string NO_WINDOW_CURRENT { + get { return ResourceManager.GetString("NO_WINDOW_CURRENT", resourceCulture); } } diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Strings_WindowsThreading.resx b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Strings_WindowsThreading.resx new file mode 100644 index 000000000..b607be977 --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/Strings_WindowsThreading.resx @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + No current Window object found to obtain a CoreDispatcher from. + Only on Jupiter. + + \ No newline at end of file diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Uwp/System.Reactive.Integration.Uwp.csproj b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/System.Reactive.Integration.Uwp.csproj new file mode 100644 index 000000000..66f046573 --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Uwp/System.Reactive.Integration.Uwp.csproj @@ -0,0 +1,24 @@ + + + + uap10.0.18362 + System.Reactive + enable + + + + Reactive Extensions (Rx) for .NET UWP (Universal Windows Platform) Integration + + + + + + + + + + + + + + diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Windows.Forms/Concurrency/ControlScheduler.cs b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Forms/Concurrency/ControlScheduler.cs new file mode 100644 index 000000000..1a71b10d7 --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Forms/Concurrency/ControlScheduler.cs @@ -0,0 +1,212 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +using System.Reactive.Disposables; +using System.Threading; +using System.Windows.Forms; + +namespace System.Reactive.Concurrency +{ + /// + /// Represents an object that schedules units of work on the message loop associated with a Windows Forms control. + /// + public class ControlScheduler : LocalScheduler, ISchedulerPeriodic + { + private readonly Control _control; + + /// + /// Constructs a ControlScheduler that schedules units of work on the message loop associated with the specified Windows Forms control. + /// + /// Windows Forms control to get the message loop from. + /// is null. + /// + /// This scheduler type is typically used indirectly through the and method overloads that take a Windows Forms control. + /// + public ControlScheduler(Control control) + { + _control = control ?? throw new ArgumentNullException(nameof(control)); + } + + /// + /// Gets the control associated with the ControlScheduler. + /// + public Control Control => _control; + + /// + /// Schedules an action to be executed on the message loop associated with the control. + /// + /// The type of the state passed to the scheduled action. + /// State passed to the action to be executed. + /// Action to be executed. + /// The disposable object used to cancel the scheduled action (best effort). + /// is null. + public override IDisposable Schedule(TState state, Func action) + { + if (action == null) + { + throw new ArgumentNullException(nameof(action)); + } + + if (_control.IsDisposed) + { + return Disposable.Empty; + } + + var d = new SingleAssignmentDisposable(); + + _control.BeginInvoke(new Action(() => + { + if (!_control.IsDisposed && !d.IsDisposed) + { + d.Disposable = action(this, state); + } + })); + + return d; + } + + /// + /// Schedules an action to be executed after dueTime on the message loop associated with the control, using a Windows Forms Timer object. + /// + /// The type of the state passed to the scheduled action. + /// State passed to the action to be executed. + /// Action to be executed. + /// Relative time after which to execute the action. + /// The disposable object used to cancel the scheduled action (best effort). + /// is null. + public override IDisposable Schedule(TState state, TimeSpan dueTime, Func action) + { + if (action == null) + { + throw new ArgumentNullException(nameof(action)); + } + + var dt = Scheduler.Normalize(dueTime); + if (dt.Ticks == 0) + { + return Schedule(state, action); + } + + var createTimer = new Func((scheduler1, state1) => + { + var d = new MultipleAssignmentDisposable(); + + var timer = new System.Windows.Forms.Timer(); + + timer.Tick += (s, e) => + { + var t = Interlocked.Exchange(ref timer, null); + if (t != null) + { + try + { + if (!_control.IsDisposed && !d.IsDisposed) + { + d.Disposable = action(scheduler1, state1); + } + } + finally + { + t.Stop(); + action = static (s, t) => Disposable.Empty; + } + } + }; + + timer.Interval = (int)dt.TotalMilliseconds; + timer.Start(); + + d.Disposable = Disposable.Create(() => + { + var t = Interlocked.Exchange(ref timer, null); + if (t != null) + { + t.Stop(); + action = static (s, t) => Disposable.Empty; + } + }); + + return d; + }); + + // + // This check is critical. When creating and enabling a Timer object on another thread than + // the UI thread, it won't fire. + // + if (_control.InvokeRequired) + { + return Schedule(state, createTimer); + } + else + { + return createTimer(this, state); + } + } + + /// + /// Schedules a periodic piece of work on the message loop associated with the control, using a Windows Forms Timer object. + /// + /// The type of the state passed to the scheduled action. + /// Initial state passed to the action upon the first iteration. + /// Period for running the work periodically. + /// Action to be executed, potentially updating the state. + /// The disposable object used to cancel the scheduled recurring action (best effort). + /// is null. + /// is less than one millisecond. + public IDisposable SchedulePeriodic(TState state, TimeSpan period, Func action) + { + // + // Threshold derived from Interval property setter in ndp\fx\src\winforms\managed\system\winforms\Timer.cs. + // + if (period.TotalMilliseconds < 1) + { + throw new ArgumentOutOfRangeException(nameof(period)); + } + + if (action == null) + { + throw new ArgumentNullException(nameof(action)); + } + + var createTimer = new Func((scheduler1, state1) => + { + var timer = new System.Windows.Forms.Timer(); + + timer.Tick += (s, e) => + { + if (!_control.IsDisposed) + { + state1 = action(state1); + } + }; + + timer.Interval = (int)period.TotalMilliseconds; + timer.Start(); + + return Disposable.Create(() => + { + var t = Interlocked.Exchange(ref timer, null); + if (t != null) + { + t.Stop(); + action = static _ => _; + } + }); + }); + + // + // This check is critical. When creating and enabling a Timer object on another thread than + // the UI thread, it won't fire. + // + if (_control.InvokeRequired) + { + return Schedule(state, createTimer); + } + else + { + return createTimer(this, state); + } + } + } +} diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/ControlObservable.cs b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Forms/Linq/ControlObservable.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/ControlObservable.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Windows.Forms/Linq/ControlObservable.cs diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Windows.Forms/System.Reactive.Integration.Windows.Forms.csproj b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Forms/System.Reactive.Integration.Windows.Forms.csproj new file mode 100644 index 000000000..694713bcf --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Forms/System.Reactive.Integration.Windows.Forms.csproj @@ -0,0 +1,18 @@ + + + + net472;net6.0-windows + System.Reactive + true + enable + + + + + + + + + + + diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/ThreadPoolScheduler.Windows.cs b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Concurrency/ThreadPoolScheduler.Windows.cs similarity index 74% rename from Rx.NET/Source/src/System.Reactive/Concurrency/ThreadPoolScheduler.Windows.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Concurrency/ThreadPoolScheduler.Windows.cs index c7bd55fc4..a2c35b7a8 100644 --- a/Rx.NET/Source/src/System.Reactive/Concurrency/ThreadPoolScheduler.Windows.cs +++ b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Concurrency/ThreadPoolScheduler.Windows.cs @@ -12,34 +12,49 @@ namespace System.Reactive.Concurrency /// Represents an object that schedules units of work on the Windows Runtime thread pool. /// /// Singleton instance of this type exposed through this static property. + /// + /// Before Rx 7.0, this functionality was found in the type - the UWP target + /// of System.Reactive had a different implementation of that class because the version of .NET available + /// on UWP back in the early days of did not provide the features that the + /// relied on, and so it was implemented in terms of the Windows Runtime thread pool. It also had a slightly + /// different API surface area making some Windows Runtime thread pool features (work item priority and options) + /// available. But when UWP added support for .NET Standard 2.0, there was no longer an absolute requirement + /// for a UWP-specific thread pool scheduler. The continued support of UWP as a target for the main Rx packages + /// was causing various problems, so for Rx 7.0, we decided to make a breaking change by replacing the UWP-specific + /// thread pool scheduler with the general purpose one. (This affects only UWP apps, and only if they upgrade + /// to Rx 7.0. We consider this to be acceptable because UWP is a platform Microsoft encourages developers not + /// to use.) However, we wanted to enable developers who were relying on the UWP-specific thread pool scheduler's + /// specialized features to be able to continue to use them. This class is the same in all but name as the + /// old UWP thread pool scheduler. + /// [CLSCompliant(false)] - public sealed class ThreadPoolScheduler : LocalScheduler, ISchedulerPeriodic + public sealed class WindowsRuntimeThreadPoolScheduler : LocalScheduler, ISchedulerPeriodic { - private static readonly Lazy LazyDefault = new(static () => new ThreadPoolScheduler()); + private static readonly Lazy LazyDefault = new(static () => new WindowsRuntimeThreadPoolScheduler()); /// - /// Constructs a ThreadPoolScheduler that schedules units of work on the Windows ThreadPool. + /// Constructs a WindowsRuntimeThreadPoolScheduler that schedules units of work on the Windows ThreadPool. /// - public ThreadPoolScheduler() + public WindowsRuntimeThreadPoolScheduler() { } /// - /// Constructs a ThreadPoolScheduler that schedules units of work on the Windows ThreadPool with the given priority. + /// Constructs a WindowsRuntimeThreadPoolScheduler that schedules units of work on the Windows ThreadPool with the given priority. /// /// Priority for scheduled units of work. - public ThreadPoolScheduler(WorkItemPriority priority) + public WindowsRuntimeThreadPoolScheduler(WorkItemPriority priority) { Priority = priority; Options = WorkItemOptions.None; } /// - /// Constructs a ThreadPoolScheduler that schedules units of work on the Windows ThreadPool with the given priority. + /// Constructs a WindowsRuntimeThreadPoolScheduler that schedules units of work on the Windows ThreadPool with the given priority. /// /// Priority for scheduled units of work. /// Options that configure how work is scheduled. - public ThreadPoolScheduler(WorkItemPriority priority, WorkItemOptions options) + public WindowsRuntimeThreadPoolScheduler(WorkItemPriority priority, WorkItemOptions options) { Priority = priority; Options = options; @@ -50,12 +65,12 @@ public ThreadPoolScheduler(WorkItemPriority priority, WorkItemOptions options) /// [Obsolete("Use the Instance property", false)] [EditorBrowsable(EditorBrowsableState.Never)] - public static ThreadPoolScheduler Default => LazyDefault.Value; + public static WindowsRuntimeThreadPoolScheduler Default => LazyDefault.Value; /// /// Gets the singleton instance of the Windows Runtime thread pool scheduler. /// - public static ThreadPoolScheduler Instance => LazyDefault.Value; + public static WindowsRuntimeThreadPoolScheduler Instance => LazyDefault.Value; /// /// Gets the priority at which work is scheduled. diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/Windows/ThreadPoolTimerExtensions.cs b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Concurrency/ThreadPoolTimerExtensions.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/Windows/ThreadPoolTimerExtensions.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Concurrency/ThreadPoolTimerExtensions.cs diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Properties/InternalsVisibleTo.cs b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Properties/InternalsVisibleTo.cs new file mode 100644 index 000000000..78717ba87 --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Properties/InternalsVisibleTo.cs @@ -0,0 +1,5 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("System.Reactive.Integration.Uwp, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/System.Reactive.Integration.Windows.Runtime.csproj b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/System.Reactive.Integration.Windows.Runtime.csproj new file mode 100644 index 000000000..1cc539153 --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/System.Reactive.Integration.Windows.Runtime.csproj @@ -0,0 +1,21 @@ + + + uap10.0.18362;net6.0-windows10.0.19041 + System.Reactive + enable + + + + Reactive Extensions (Rx) for .NET Windows Runtime Integration + + + + + + + + + + + + diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Foundation/AsyncInfoExtensions.cs b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Windows/Foundation/AsyncInfoExtensions.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/UWP/Foundation/AsyncInfoExtensions.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Windows/Foundation/AsyncInfoExtensions.cs diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Foundation/AsyncInfoToObservableBridge.cs b/Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Windows/Foundation/AsyncInfoToObservableBridge.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/UWP/Foundation/AsyncInfoToObservableBridge.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Windows.Runtime/Windows/Foundation/AsyncInfoToObservableBridge.cs diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Concurrency/DispatcherScheduler.cs b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Concurrency/DispatcherScheduler.cs new file mode 100644 index 000000000..613ec646e --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Concurrency/DispatcherScheduler.cs @@ -0,0 +1,213 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +#if HAS_WPF +using System.Reactive.Disposables; +using System.Threading; + +namespace System.Reactive.Concurrency +{ + /// + /// Represents an object that schedules units of work on a . + /// + /// + /// This scheduler type is typically used indirectly through the and methods that use the Dispatcher on the calling thread. + /// + public class DispatcherScheduler : LocalScheduler, ISchedulerPeriodic + { + /// + /// Gets the scheduler that schedules work on the current . + /// + [Obsolete(Constants_WindowsThreading.OBSOLETE_INSTANCE_PROPERTY)] + public static DispatcherScheduler Instance => new(System.Windows.Threading.Dispatcher.CurrentDispatcher); + + /// + /// Gets the scheduler that schedules work on the for the current thread. + /// + public static DispatcherScheduler Current + { + get + { + var dispatcher = System.Windows.Threading.Dispatcher.FromThread(Thread.CurrentThread) + ?? throw new InvalidOperationException(Strings_WindowsThreading.NO_DISPATCHER_CURRENT_THREAD); + return new DispatcherScheduler(dispatcher); + } + } + + /// + /// Constructs a that schedules units of work on the given . + /// + /// to schedule work on. + /// is null. + public DispatcherScheduler(System.Windows.Threading.Dispatcher dispatcher) + { + Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher)); + Priority = System.Windows.Threading.DispatcherPriority.Normal; + + } + + /// + /// Constructs a that schedules units of work on the given at the given priority. + /// + /// to schedule work on. + /// Priority at which units of work are scheduled. + /// is null. + public DispatcherScheduler(System.Windows.Threading.Dispatcher dispatcher, System.Windows.Threading.DispatcherPriority priority) + { + Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher)); + Priority = priority; + } + + /// + /// Gets the associated with the . + /// + public System.Windows.Threading.Dispatcher Dispatcher { get; } + + /// + /// Gets the priority at which work items will be dispatched. + /// + public System.Windows.Threading.DispatcherPriority Priority { get; } + + /// + /// Schedules an action to be executed on the dispatcher. + /// + /// The type of the state passed to the scheduled action. + /// State passed to the action to be executed. + /// Action to be executed. + /// The disposable object used to cancel the scheduled action (best effort). + /// is null. + public override IDisposable Schedule(TState state, Func action) + { + if (action == null) + { + throw new ArgumentNullException(nameof(action)); + } + + var d = new SingleAssignmentDisposable(); + + Dispatcher.BeginInvoke( + new Action(() => + { + if (!d.IsDisposed) + { + d.Disposable = action(this, state); + } + }), + Priority + ); + + return d; + } + + /// + /// Schedules an action to be executed after on the dispatcher, using a object. + /// + /// The type of the state passed to the scheduled action. + /// State passed to the action to be executed. + /// Action to be executed. + /// Relative time after which to execute the action. + /// The disposable object used to cancel the scheduled action (best effort). + /// is null. + public override IDisposable Schedule(TState state, TimeSpan dueTime, Func action) + { + if (action == null) + { + throw new ArgumentNullException(nameof(action)); + } + + var dt = Scheduler.Normalize(dueTime); + if (dt.Ticks == 0) + { + return Schedule(state, action); + } + + return ScheduleSlow(state, dt, action); + } + + private IDisposable ScheduleSlow(TState state, TimeSpan dueTime, Func action) + { + var d = new MultipleAssignmentDisposable(); + + var timer = new System.Windows.Threading.DispatcherTimer(Priority, Dispatcher); + + timer.Tick += (s, e) => + { + var t = Interlocked.Exchange(ref timer, null); + if (t != null) + { + try + { + d.Disposable = action(this, state); + } + finally + { + t.Stop(); + action = static (s, t) => Disposable.Empty; + } + } + }; + + timer.Interval = dueTime; + timer.Start(); + + d.Disposable = Disposable.Create(() => + { + var t = Interlocked.Exchange(ref timer, null); + if (t != null) + { + t.Stop(); + action = static (s, t) => Disposable.Empty; + } + }); + + return d; + } + + /// + /// Schedules a periodic piece of work on the dispatcher, using a object. + /// + /// The type of the state passed to the scheduled action. + /// Initial state passed to the action upon the first iteration. + /// Period for running the work periodically. + /// Action to be executed, potentially updating the state. + /// The disposable object used to cancel the scheduled recurring action (best effort). + /// is null. + /// is less than . + public IDisposable SchedulePeriodic(TState state, TimeSpan period, Func action) + { + if (period < TimeSpan.Zero) + { + throw new ArgumentOutOfRangeException(nameof(period)); + } + + if (action == null) + { + throw new ArgumentNullException(nameof(action)); + } + + var timer = new System.Windows.Threading.DispatcherTimer(Priority, Dispatcher); + + var state1 = state; + + timer.Tick += (s, e) => + { + state1 = action(state1); + }; + + timer.Interval = period; + timer.Start(); + + return Disposable.Create(() => + { + var t = Interlocked.Exchange(ref timer, null); + if (t != null) + { + t.Stop(); + action = static _ => _; + } + }); + } + } +} +#endif diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Internal/Constants.cs b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Constants.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Internal/Constants.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Wpf/Constants.cs diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/DispatcherObservable.cs b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Linq/DispatcherObservable.cs similarity index 100% rename from Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/DispatcherObservable.cs rename to Rx.NET/Source/src/System.Reactive.Integration.Wpf/Linq/DispatcherObservable.cs diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Strings_WindowsThreading.Designer.cs b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Strings_WindowsThreading.Designer.cs new file mode 100644 index 000000000..d3edf0f72 --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Strings_WindowsThreading.Designer.cs @@ -0,0 +1,72 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace System.Reactive { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Strings_WindowsThreading { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Strings_WindowsThreading() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_WindowsThreading", typeof(Strings_WindowsThreading).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to The current thread has no Dispatcher associated with it.. + /// + internal static string NO_DISPATCHER_CURRENT_THREAD { + get { + return ResourceManager.GetString("NO_DISPATCHER_CURRENT_THREAD", resourceCulture); + } + } + } +} diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/Windows/Strings_WindowsThreading.resx b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Strings_WindowsThreading.resx similarity index 96% rename from Rx.NET/Source/src/System.Reactive/Platforms/Windows/Strings_WindowsThreading.resx rename to Rx.NET/Source/src/System.Reactive.Integration.Wpf/Strings_WindowsThreading.resx index 85f51011e..4b8c1b341 100644 --- a/Rx.NET/Source/src/System.Reactive/Platforms/Windows/Strings_WindowsThreading.resx +++ b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/Strings_WindowsThreading.resx @@ -121,8 +121,4 @@ The current thread has no Dispatcher associated with it. Only on WPF/SL. - - No current Window object found to obtain a CoreDispatcher from. - Only on Jupiter. - \ No newline at end of file diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Wpf/System - Backup.Reactive.Integration.Wpf.csproj b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/System - Backup.Reactive.Integration.Wpf.csproj new file mode 100644 index 000000000..c3d16f690 --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/System - Backup.Reactive.Integration.Wpf.csproj @@ -0,0 +1,31 @@ + + + + net472;net6.0-windows + System.Reactive + + + + + + + + + true + Strings_WindowsThreading.resx + True + True + + + + + + %(RecursiveDir)%(Filename)$(ExtrasDefaultDesignerFileSuffix)$(DefaultLanguageSourceExtension) + System.Reactive + <_SdkHasLangId>$([System.Text.RegularExpressions.Regex]::IsMatch('%(FileName)', '$(_SdkLangIdRegEx)')) + Strings_WindowsThreading.Designer.cs + ResXFileCodeGenerator + + + + diff --git a/Rx.NET/Source/src/System.Reactive.Integration.Wpf/System.Reactive.Integration.Wpf.csproj b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/System.Reactive.Integration.Wpf.csproj new file mode 100644 index 000000000..06f9883f3 --- /dev/null +++ b/Rx.NET/Source/src/System.Reactive.Integration.Wpf/System.Reactive.Integration.Wpf.csproj @@ -0,0 +1,20 @@ + + + + net472;net6.0-windows + System.Reactive + true + + + + + + + + + + + + + + diff --git a/Rx.NET/Source/src/System.Reactive.Observable.Aliases/System.Reactive.Observable.Aliases.csproj b/Rx.NET/Source/src/System.Reactive.Observable.Aliases/System.Reactive.Observable.Aliases.csproj index 827da992a..cbd7cf719 100644 --- a/Rx.NET/Source/src/System.Reactive.Observable.Aliases/System.Reactive.Observable.Aliases.csproj +++ b/Rx.NET/Source/src/System.Reactive.Observable.Aliases/System.Reactive.Observable.Aliases.csproj @@ -1,6 +1,6 @@ - + - netstandard2.0;net472;uap10.0.18362;net6.0 + netstandard2.0;net6.0 Reactive Extensions - Aliases false Rx;Reactive;Extensions;Observable;LINQ;Events @@ -10,11 +10,12 @@ - - + + + - + \ No newline at end of file diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/ThreadPoolScheduler.cs b/Rx.NET/Source/src/System.Reactive/Concurrency/ThreadPoolScheduler.cs index d9163ece9..4ca32a647 100644 --- a/Rx.NET/Source/src/System.Reactive/Concurrency/ThreadPoolScheduler.cs +++ b/Rx.NET/Source/src/System.Reactive/Concurrency/ThreadPoolScheduler.cs @@ -2,7 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT License. // See the LICENSE file in the project root for more information. -#if !LEGACY_WINRT using System.Reactive.Disposables; using System.Threading; @@ -224,4 +223,3 @@ public void Dispose() } } } -#endif diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.CombineLatest.tt b/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.CombineLatest.tt index 3a175af43..cfe2d804c 100644 --- a/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.CombineLatest.tt +++ b/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.CombineLatest.tt @@ -78,7 +78,9 @@ for (int j = 0; j < i; j++) #> } +#pragma warning disable CA1711 // (Don't use Ex suffix.) This has been a public type for many years, so we can't rename it now. public static partial class ObservableEx +#pragma warning restore CA1711 { <# for (int i = 2; i <= 8; i++) diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.Zip.tt b/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.Zip.tt index b070483b1..89bbb46ca 100644 --- a/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.Zip.tt +++ b/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.Zip.tt @@ -77,7 +77,9 @@ for (int j = 0; j < i; j++) #> } +#pragma warning disable CA1711 // (Don't use Ex suffix.) This has been a public type for many years, so we can't rename it now. public static partial class ObservableEx +#pragma warning restore CA1711 { <# for (int i = 2; i <= 8; i++) diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.cs b/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.cs index 5df75275c..ec1a35a2e 100644 --- a/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.cs +++ b/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.cs @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT License. // See the LICENSE file in the project root for more information. -// This code was generated by a T4 template at 04/19/2023 18:04:44. +// This code was generated by a T4 template at 11/03/2023 13:38:50. using System.Linq.Expressions; using System.Reflection; @@ -34,11 +34,11 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond)), +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second) ) ); -#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. } /// @@ -66,7 +66,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third) @@ -103,7 +103,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -145,7 +145,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -192,7 +192,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -244,7 +244,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -301,7 +301,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -363,7 +363,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -430,7 +430,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -502,7 +502,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -579,7 +579,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -661,7 +661,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth), typeof(TThirteenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -748,7 +748,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth), typeof(TThirteenth), typeof(TFourteenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -840,7 +840,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth), typeof(TThirteenth), typeof(TFourteenth), typeof(TFifteenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -937,7 +937,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth), typeof(TThirteenth), typeof(TFourteenth), typeof(TFifteenth), typeof(TSixteenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -979,7 +979,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second) ) @@ -1011,7 +1011,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third) @@ -1048,7 +1048,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1090,7 +1090,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1137,7 +1137,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1189,7 +1189,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1246,7 +1246,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1308,7 +1308,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1375,7 +1375,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1447,7 +1447,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1524,7 +1524,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1606,7 +1606,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth), typeof(TThirteenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1693,7 +1693,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth), typeof(TThirteenth), typeof(TFourteenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1785,7 +1785,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth), typeof(TThirteenth), typeof(TFourteenth), typeof(TFifteenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), @@ -1882,7 +1882,7 @@ public static partial class QbservableEx null, #pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh), typeof(TEighth), typeof(TNinth), typeof(TTenth), typeof(TEleventh), typeof(TTwelfth), typeof(TThirteenth), typeof(TFourteenth), typeof(TFifteenth), typeof(TSixteenth)), -#pragma warning restore IL2060 +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, GetSourceExpression(second), GetSourceExpression(third), diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.tt b/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.tt index 4f0453f3a..efbd06d21 100644 --- a/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.tt +++ b/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.tt @@ -15,7 +15,9 @@ using System.Reflection; namespace System.Reactive.Linq { +#pragma warning disable CA1711 // (Don't use Ex suffix.) This has been a public type for many years, so we can't rename it now. public static partial class QbservableEx +#pragma warning restore CA1711 { <# Func toUpper = s => char.ToUpper(s[0]) + s.Substring(1); @@ -69,7 +71,9 @@ for (int j = 1; j <= i; j++) return first.Provider.CreateQuery<<#=tuple#>>( Expression.Call( null, +#pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(<#=typeofGenArgs#>), +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, <# for (int j = 2; j <= i; j++) @@ -133,7 +137,9 @@ for (int j = 1; j <= i; j++) return first.Provider.CreateQuery<<#=tuple#>>( Expression.Call( null, +#pragma warning disable IL2060 // ('System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed.) This gets the MethodInfo for the method running right now, so it can't have been trimmed ((MethodInfo)MethodInfo.GetCurrentMethod()!).MakeGenericMethod(<#=typeofGenArgs#>), +#pragma warning restore IL2060 // Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. first.Expression, <# for (int j = 2; j <= i; j++) diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.CombineLatest.cs b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.CombineLatest.cs index fe204bb08..ffb081695 100644 --- a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.CombineLatest.cs +++ b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.CombineLatest.cs @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT License. // See the LICENSE file in the project root for more information. -// This code was generated by a T4 template at 10/05/2020 14:25:15. +// This code was generated by a T4 template at 11/03/2023 13:26:30. namespace System.Reactive.Linq { diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.Zip.cs b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.Zip.cs index 1adad4fe1..95bf951b8 100644 --- a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.Zip.cs +++ b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.Zip.cs @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT License. // See the LICENSE file in the project root for more information. -// This code was generated by a T4 template at 10/05/2020 14:25:21. +// This code was generated by a T4 template at 11/03/2023 13:26:30. namespace System.Reactive.Linq { diff --git a/Rx.NET/Source/src/System.Reactive/Properties/InternalsVisibleTo.cs b/Rx.NET/Source/src/System.Reactive/Properties/InternalsVisibleTo.cs index 8eac4a74a..bcefc76d0 100644 --- a/Rx.NET/Source/src/System.Reactive/Properties/InternalsVisibleTo.cs +++ b/Rx.NET/Source/src/System.Reactive/Properties/InternalsVisibleTo.cs @@ -2,5 +2,10 @@ // The .NET Foundation licenses this file to you under the MIT License. // See the LICENSE file in the project root for more information. +// TODO: this is here only because RemotingObservable is in here; not clear where its home should be. +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("System.Reactive, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] + +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("System.Reactive.Integration.Uwp, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("System.Reactive.Integration.Windows.Runtime, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Tests.System.Reactive, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Tests.System.Reactive.Uwp.DeviceRunner, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] \ No newline at end of file +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Tests.System.Reactive.Uwp.DeviceRunner, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] diff --git a/Rx.NET/Source/src/System.Reactive/Strings_Core.Designer.cs b/Rx.NET/Source/src/System.Reactive/Strings_Core.Designer.cs index b619d164c..5edcebcc8 100644 --- a/Rx.NET/Source/src/System.Reactive/Strings_Core.Designer.cs +++ b/Rx.NET/Source/src/System.Reactive/Strings_Core.Designer.cs @@ -8,11 +8,10 @@ // //------------------------------------------------------------------------------ -namespace System.Reactive -{ - using System.Reflection; - - +namespace System.Reactive { + using System; + + /// /// A strongly-typed resource class, for looking up localized strings, etc. /// @@ -20,150 +19,124 @@ namespace System.Reactive // class via a tool like ResGen or Visual Studio. // To add or remove a member, edit your .ResX file then rerun ResGen // with the /str option, or rebuild your VS project. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] - internal class Strings_Core - { - + internal class Strings_Core { + private static global::System.Resources.ResourceManager resourceMan; - + private static global::System.Globalization.CultureInfo resourceCulture; - + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] - internal Strings_Core() - { + internal Strings_Core() { } - + /// /// Returns the cached ResourceManager instance used by this class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Resources.ResourceManager ResourceManager - { - get - { - if (object.ReferenceEquals(resourceMan, null)) - { - global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_Core", typeof(Strings_Core).GetTypeInfo().Assembly); + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_Core", typeof(Strings_Core).Assembly); resourceMan = temp; } return resourceMan; } } - + /// /// Overrides the current thread's CurrentUICulture property for all /// resource lookups using this strongly typed resource class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Globalization.CultureInfo Culture - { - get - { + internal static global::System.Globalization.CultureInfo Culture { + get { return resourceCulture; } - set - { + set { resourceCulture = value; } } - + /// /// Looks up a localized string similar to Using the Scheduler.{0} property is no longer supported due to refactoring of the API surface and elimination of platform-specific dependencies. Please include System.Reactive.PlatformServices for your target platform and use the {0}Scheduler type instead. If you're building a Windows Store app, notice some schedulers are no longer supported. Consider using Scheduler.Default instead.. /// - internal static string CANT_OBTAIN_SCHEDULER - { - get - { + internal static string CANT_OBTAIN_SCHEDULER { + get { return ResourceManager.GetString("CANT_OBTAIN_SCHEDULER", resourceCulture); } } - + /// - /// Looks up a localized string similar to OnCompleted notification doesn't have a value.. + /// Looks up a localized string similar to OnCompleted notification doesn't have a value.. /// - internal static string COMPLETED_NO_VALUE - { - get - { + internal static string COMPLETED_NO_VALUE { + get { return ResourceManager.GetString("COMPLETED_NO_VALUE", resourceCulture); } } - + /// /// Looks up a localized string similar to Disposable has already been assigned.. /// - internal static string DISPOSABLE_ALREADY_ASSIGNED - { - get - { + internal static string DISPOSABLE_ALREADY_ASSIGNED { + get { return ResourceManager.GetString("DISPOSABLE_ALREADY_ASSIGNED", resourceCulture); } } - + /// /// Looks up a localized string similar to Disposables collection can not contain null values.. /// - internal static string DISPOSABLES_CANT_CONTAIN_NULL - { - get - { + internal static string DISPOSABLES_CANT_CONTAIN_NULL { + get { return ResourceManager.GetString("DISPOSABLES_CANT_CONTAIN_NULL", resourceCulture); } } - + /// /// Looks up a localized string similar to Failed to start monitoring system clock changes.. /// - internal static string FAILED_CLOCK_MONITORING - { - get - { + internal static string FAILED_CLOCK_MONITORING { + get { return ResourceManager.GetString("FAILED_CLOCK_MONITORING", resourceCulture); } } - + /// /// Looks up a localized string similar to Heap is empty.. /// - internal static string HEAP_EMPTY - { - get - { + internal static string HEAP_EMPTY { + get { return ResourceManager.GetString("HEAP_EMPTY", resourceCulture); } } - + /// /// Looks up a localized string similar to Observer has already terminated.. /// - internal static string OBSERVER_TERMINATED - { - get - { + internal static string OBSERVER_TERMINATED { + get { return ResourceManager.GetString("OBSERVER_TERMINATED", resourceCulture); } } - + /// /// Looks up a localized string similar to Reentrancy has been detected.. /// - internal static string REENTRANCY_DETECTED - { - get - { + internal static string REENTRANCY_DETECTED { + get { return ResourceManager.GetString("REENTRANCY_DETECTED", resourceCulture); } } - + /// /// Looks up a localized string similar to This scheduler operation has already been awaited.. /// - internal static string SCHEDULER_OPERATION_ALREADY_AWAITED - { - get - { + internal static string SCHEDULER_OPERATION_ALREADY_AWAITED { + get { return ResourceManager.GetString("SCHEDULER_OPERATION_ALREADY_AWAITED", resourceCulture); } } diff --git a/Rx.NET/Source/src/System.Reactive/Strings_Linq.Designer.cs b/Rx.NET/Source/src/System.Reactive/Strings_Linq.Designer.cs index 8bd0869b2..79cf84715 100644 --- a/Rx.NET/Source/src/System.Reactive/Strings_Linq.Designer.cs +++ b/Rx.NET/Source/src/System.Reactive/Strings_Linq.Designer.cs @@ -8,11 +8,10 @@ // //------------------------------------------------------------------------------ -namespace System.Reactive -{ - using System.Reflection; - - +namespace System.Reactive { + using System; + + /// /// A strongly-typed resource class, for looking up localized strings, etc. /// @@ -20,227 +19,187 @@ namespace System.Reactive // class via a tool like ResGen or Visual Studio. // To add or remove a member, edit your .ResX file then rerun ResGen // with the /str option, or rebuild your VS project. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] - internal class Strings_Linq - { - + internal class Strings_Linq { + private static global::System.Resources.ResourceManager resourceMan; - + private static global::System.Globalization.CultureInfo resourceCulture; - + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] - internal Strings_Linq() - { + internal Strings_Linq() { } - + /// /// Returns the cached ResourceManager instance used by this class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Resources.ResourceManager ResourceManager - { - get - { - if (object.ReferenceEquals(resourceMan, null)) - { - global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_Linq", typeof(Strings_Linq).GetTypeInfo().Assembly); + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_Linq", typeof(Strings_Linq).Assembly); resourceMan = temp; } return resourceMan; } } - + /// /// Overrides the current thread's CurrentUICulture property for all /// resource lookups using this strongly typed resource class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Globalization.CultureInfo Culture - { - get - { + internal static global::System.Globalization.CultureInfo Culture { + get { return resourceCulture; } - set - { + set { resourceCulture = value; } } - + /// /// Looks up a localized string similar to {0} cannot be called when the scheduler is already running. Try using Sleep instead.. /// - internal static string CANT_ADVANCE_WHILE_RUNNING - { - get - { + internal static string CANT_ADVANCE_WHILE_RUNNING { + get { return ResourceManager.GetString("CANT_ADVANCE_WHILE_RUNNING", resourceCulture); } } - + /// /// Looks up a localized string similar to Could not find event '{0}' on object of type '{1}'.. /// - internal static string COULD_NOT_FIND_INSTANCE_EVENT - { - get - { + internal static string COULD_NOT_FIND_INSTANCE_EVENT { + get { return ResourceManager.GetString("COULD_NOT_FIND_INSTANCE_EVENT", resourceCulture); } } - + /// /// Looks up a localized string similar to Could not find event '{0}' on type '{1}'.. /// - internal static string COULD_NOT_FIND_STATIC_EVENT - { - get - { + internal static string COULD_NOT_FIND_STATIC_EVENT { + get { return ResourceManager.GetString("COULD_NOT_FIND_STATIC_EVENT", resourceCulture); } } - + /// /// Looks up a localized string similar to Add method should take 1 parameter.. /// - internal static string EVENT_ADD_METHOD_SHOULD_TAKE_ONE_PARAMETER - { - get - { + internal static string EVENT_ADD_METHOD_SHOULD_TAKE_ONE_PARAMETER { + get { return ResourceManager.GetString("EVENT_ADD_METHOD_SHOULD_TAKE_ONE_PARAMETER", resourceCulture); } } - + /// /// Looks up a localized string similar to The second parameter of the event delegate must be assignable to '{0}'.. /// - internal static string EVENT_ARGS_NOT_ASSIGNABLE - { - get - { + internal static string EVENT_ARGS_NOT_ASSIGNABLE { + get { return ResourceManager.GetString("EVENT_ARGS_NOT_ASSIGNABLE", resourceCulture); } } - + /// /// Looks up a localized string similar to Event is missing the add method.. /// - internal static string EVENT_MISSING_ADD_METHOD - { - get - { + internal static string EVENT_MISSING_ADD_METHOD { + get { return ResourceManager.GetString("EVENT_MISSING_ADD_METHOD", resourceCulture); } } - + /// /// Looks up a localized string similar to Event is missing the remove method.. /// - internal static string EVENT_MISSING_REMOVE_METHOD - { - get - { + internal static string EVENT_MISSING_REMOVE_METHOD { + get { return ResourceManager.GetString("EVENT_MISSING_REMOVE_METHOD", resourceCulture); } } - + /// /// Looks up a localized string similar to The event delegate must have a void return type.. /// - internal static string EVENT_MUST_RETURN_VOID - { - get - { + internal static string EVENT_MUST_RETURN_VOID { + get { return ResourceManager.GetString("EVENT_MUST_RETURN_VOID", resourceCulture); } } - + /// /// Looks up a localized string similar to The event delegate must have exactly two parameters.. /// - internal static string EVENT_PATTERN_REQUIRES_TWO_PARAMETERS - { - get - { + internal static string EVENT_PATTERN_REQUIRES_TWO_PARAMETERS { + get { return ResourceManager.GetString("EVENT_PATTERN_REQUIRES_TWO_PARAMETERS", resourceCulture); } } - + /// /// Looks up a localized string similar to Remove method should take 1 parameter.. /// - internal static string EVENT_REMOVE_METHOD_SHOULD_TAKE_ONE_PARAMETER - { - get - { + internal static string EVENT_REMOVE_METHOD_SHOULD_TAKE_ONE_PARAMETER { + get { return ResourceManager.GetString("EVENT_REMOVE_METHOD_SHOULD_TAKE_ONE_PARAMETER", resourceCulture); } } - + /// /// Looks up a localized string similar to The first parameter of the event delegate must be assignable to '{0}'.. /// - internal static string EVENT_SENDER_NOT_ASSIGNABLE - { - get - { + internal static string EVENT_SENDER_NOT_ASSIGNABLE { + get { return ResourceManager.GetString("EVENT_SENDER_NOT_ASSIGNABLE", resourceCulture); } } - + /// /// Looks up a localized string similar to Remove method of a WinRT event should take an EventRegistrationToken.. /// - internal static string EVENT_WINRT_REMOVE_METHOD_SHOULD_TAKE_ERT - { - get - { + internal static string EVENT_WINRT_REMOVE_METHOD_SHOULD_TAKE_ERT { + get { return ResourceManager.GetString("EVENT_WINRT_REMOVE_METHOD_SHOULD_TAKE_ERT", resourceCulture); } } - + /// /// Looks up a localized string similar to Sequence contains more than one element.. /// - internal static string MORE_THAN_ONE_ELEMENT - { - get - { + internal static string MORE_THAN_ONE_ELEMENT { + get { return ResourceManager.GetString("MORE_THAN_ONE_ELEMENT", resourceCulture); } } - + /// /// Looks up a localized string similar to Sequence contains more than one matching element.. /// - internal static string MORE_THAN_ONE_MATCHING_ELEMENT - { - get - { + internal static string MORE_THAN_ONE_MATCHING_ELEMENT { + get { return ResourceManager.GetString("MORE_THAN_ONE_MATCHING_ELEMENT", resourceCulture); } } - + /// /// Looks up a localized string similar to Sequence contains no elements.. /// - internal static string NO_ELEMENTS - { - get - { + internal static string NO_ELEMENTS { + get { return ResourceManager.GetString("NO_ELEMENTS", resourceCulture); } } - + /// /// Looks up a localized string similar to Sequence contains no matching element.. /// - internal static string NO_MATCHING_ELEMENTS - { - get - { + internal static string NO_MATCHING_ELEMENTS { + get { return ResourceManager.GetString("NO_MATCHING_ELEMENTS", resourceCulture); } } diff --git a/Rx.NET/Source/src/System.Reactive/Strings_PlatformServices.Designer.cs b/Rx.NET/Source/src/System.Reactive/Strings_PlatformServices.Designer.cs index a8f6c5a1a..3c40ff45a 100644 --- a/Rx.NET/Source/src/System.Reactive/Strings_PlatformServices.Designer.cs +++ b/Rx.NET/Source/src/System.Reactive/Strings_PlatformServices.Designer.cs @@ -8,11 +8,10 @@ // //------------------------------------------------------------------------------ -namespace System.Reactive -{ - using System.Reflection; - - +namespace System.Reactive { + using System; + + /// /// A strongly-typed resource class, for looking up localized strings, etc. /// @@ -20,62 +19,52 @@ namespace System.Reactive // class via a tool like ResGen or Visual Studio. // To add or remove a member, edit your .ResX file then rerun ResGen // with the /str option, or rebuild your VS project. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] - internal class Strings_PlatformServices - { - + internal class Strings_PlatformServices { + private static global::System.Resources.ResourceManager resourceMan; - + private static global::System.Globalization.CultureInfo resourceCulture; - + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] - internal Strings_PlatformServices() - { + internal Strings_PlatformServices() { } - + /// /// Returns the cached ResourceManager instance used by this class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Resources.ResourceManager ResourceManager - { - get - { - if (object.ReferenceEquals(resourceMan, null)) - { - global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_PlatformServices", typeof(Strings_PlatformServices).GetTypeInfo().Assembly); + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_PlatformServices", typeof(Strings_PlatformServices).Assembly); resourceMan = temp; } return resourceMan; } } - + /// /// Overrides the current thread's CurrentUICulture property for all /// resource lookups using this strongly typed resource class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Globalization.CultureInfo Culture - { - get - { + internal static global::System.Globalization.CultureInfo Culture { + get { return resourceCulture; } - set - { + set { resourceCulture = value; } } - + /// /// Looks up a localized string similar to The WinRT thread pool doesn't support creating periodic timers with a period below 1 millisecond.. /// - internal static string WINRT_NO_SUB1MS_TIMERS - { - get - { + internal static string WINRT_NO_SUB1MS_TIMERS { + get { return ResourceManager.GetString("WINRT_NO_SUB1MS_TIMERS", resourceCulture); } } diff --git a/Rx.NET/Source/src/System.Reactive/Strings_Providers.Designer.cs b/Rx.NET/Source/src/System.Reactive/Strings_Providers.Designer.cs index b6634f179..1ae0dff27 100644 --- a/Rx.NET/Source/src/System.Reactive/Strings_Providers.Designer.cs +++ b/Rx.NET/Source/src/System.Reactive/Strings_Providers.Designer.cs @@ -8,11 +8,10 @@ // //------------------------------------------------------------------------------ -namespace System.Reactive -{ - using System.Reflection; - - +namespace System.Reactive { + using System; + + /// /// A strongly-typed resource class, for looking up localized strings, etc. /// @@ -20,84 +19,70 @@ namespace System.Reactive // class via a tool like ResGen or Visual Studio. // To add or remove a member, edit your .ResX file then rerun ResGen // with the /str option, or rebuild your VS project. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] - internal class Strings_Providers - { - + internal class Strings_Providers { + private static global::System.Resources.ResourceManager resourceMan; - + private static global::System.Globalization.CultureInfo resourceCulture; - + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] - internal Strings_Providers() - { + internal Strings_Providers() { } - + /// /// Returns the cached ResourceManager instance used by this class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Resources.ResourceManager ResourceManager - { - get - { - if (object.ReferenceEquals(resourceMan, null)) - { - global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_Providers", typeof(Strings_Providers).GetTypeInfo().Assembly); + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Reactive.Strings_Providers", typeof(Strings_Providers).Assembly); resourceMan = temp; } return resourceMan; } } - + /// /// Overrides the current thread's CurrentUICulture property for all /// resource lookups using this strongly typed resource class. /// [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Globalization.CultureInfo Culture - { - get - { + internal static global::System.Globalization.CultureInfo Culture { + get { return resourceCulture; } - set - { + set { resourceCulture = value; } } - + /// /// Looks up a localized string similar to Expected Qbservable.ToQueryable.. /// - internal static string EXPECTED_TOQUERYABLE_METHODCALL - { - get - { + internal static string EXPECTED_TOQUERYABLE_METHODCALL { + get { return ResourceManager.GetString("EXPECTED_TOQUERYABLE_METHODCALL", resourceCulture); } } - + /// /// Looks up a localized string similar to Invalid expression tree type.. /// - internal static string INVALID_TREE_TYPE - { - get - { + internal static string INVALID_TREE_TYPE { + get { return ResourceManager.GetString("INVALID_TREE_TYPE", resourceCulture); } } - + /// /// Looks up a localized string similar to There is no method '{0}' on type '{1}' that matches the specified arguments.. /// - internal static string NO_MATCHING_METHOD_FOUND - { - get - { + internal static string NO_MATCHING_METHOD_FOUND { + get { return ResourceManager.GetString("NO_MATCHING_METHOD_FOUND", resourceCulture); } } diff --git a/Rx.NET/Source/src/System.Reactive/System.Reactive.csproj b/Rx.NET/Source/src/System.Reactive/System.Reactive.Base.csproj similarity index 92% rename from Rx.NET/Source/src/System.Reactive/System.Reactive.csproj rename to Rx.NET/Source/src/System.Reactive/System.Reactive.Base.csproj index f03416d01..ade45e67a 100644 --- a/Rx.NET/Source/src/System.Reactive/System.Reactive.csproj +++ b/Rx.NET/Source/src/System.Reactive/System.Reactive.Base.csproj @@ -1,10 +1,11 @@ - + - netstandard2.0;net472;uap10.0.18362;net6.0;net6.0-windows10.0.19041 + netstandard2.0;net6.0 false Rx;Reactive;Extensions;Observable;LINQ;Events Reactive Extensions (Rx) for .NET readme.md + System.Reactive @@ -31,8 +32,6 @@ TextTemplatingFileGenerator QbservableEx.NAry.cs - - @@ -150,7 +149,7 @@ - + @@ -164,4 +163,12 @@ + + + + + + + + diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Aliases.verified.cs b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Aliases.verified.cs index d7a2e3a97..5358f95d8 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Aliases.verified.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Aliases.verified.cs @@ -1,7 +1,7 @@ -[assembly: System.CLSCompliant(true)] +[assembly: System.CLSCompliant(true)] [assembly: System.Resources.NeutralResourcesLanguage("en-US")] [assembly: System.Runtime.InteropServices.ComVisible(false)] -[assembly: System.Runtime.Versioning.TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName=".NET Framework 4.7.2")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName=".NET Standard 2.0")] namespace System.Reactive.Linq { [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] @@ -60,4 +60,4 @@ public static System.IObservable FlatMap public static System.IObservable Map(this System.IObservable source, System.Func selector) { } public static System.IObservable Map(this System.IObservable source, System.Func selector) { } } -} \ No newline at end of file +} diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.verified.cs b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.verified.cs index 6e3936ec8..dc5680302 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.verified.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.verified.cs @@ -1,9 +1,12 @@ [assembly: System.CLSCompliant(true)] [assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"System.Reactive, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"System.Reactive.Integration.Uwp, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"System.Reactive.Integration.Windows.Runtime, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] [assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Tests.System.Reactive, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] [assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Tests.System.Reactive.Uwp.DeviceRunner, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] [assembly: System.Runtime.InteropServices.ComVisible(false)] -[assembly: System.Runtime.Versioning.TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName=".NET Framework 4.7.2")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName=".NET Standard 2.0")] namespace System { public static class ObservableExtensions @@ -236,14 +239,6 @@ public AsyncLock() { } public void Dispose() { } public void Wait(System.Action action) { } } - public class ControlScheduler : System.Reactive.Concurrency.LocalScheduler, System.Reactive.Concurrency.ISchedulerPeriodic - { - public ControlScheduler(System.Windows.Forms.Control control) { } - public System.Windows.Forms.Control Control { get; } - public override System.IDisposable Schedule(TState state, System.Func action) { } - public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } - public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } - } public sealed class CurrentThreadScheduler : System.Reactive.Concurrency.LocalScheduler { [System.Obsolete("This instance property is no longer supported. Use CurrentThreadScheduler.IsSched" + @@ -261,20 +256,6 @@ public override System.IDisposable Schedule(TState state, System.Func(TState state, System.TimeSpan dueTime, System.Func action) { } public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } } - public class DispatcherScheduler : System.Reactive.Concurrency.LocalScheduler, System.Reactive.Concurrency.ISchedulerPeriodic - { - public DispatcherScheduler(System.Windows.Threading.Dispatcher dispatcher) { } - public DispatcherScheduler(System.Windows.Threading.Dispatcher dispatcher, System.Windows.Threading.DispatcherPriority priority) { } - public System.Windows.Threading.Dispatcher Dispatcher { get; } - public System.Windows.Threading.DispatcherPriority Priority { get; } - public static System.Reactive.Concurrency.DispatcherScheduler Current { get; } - [System.Obsolete("Use the Current property to retrieve the DispatcherScheduler instance for the cur" + - "rent thread\'s Dispatcher object.")] - public static System.Reactive.Concurrency.DispatcherScheduler Instance { get; } - public override System.IDisposable Schedule(TState state, System.Func action) { } - public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } - public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } - } public sealed class EventLoopScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic { public EventLoopScheduler() { } @@ -829,28 +810,6 @@ public class QueryablePlan } namespace System.Reactive.Linq { - public static class ControlObservable - { - public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Forms.Control control) { } - public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Forms.Control control) { } - } - public static class DispatcherObservable - { - public static System.IObservable ObserveOn(this System.IObservable source, System.Reactive.Concurrency.DispatcherScheduler scheduler) { } - public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Threading.Dispatcher dispatcher) { } - public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Threading.DispatcherObject dispatcherObject) { } - public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Threading.Dispatcher dispatcher, System.Windows.Threading.DispatcherPriority priority) { } - public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Threading.DispatcherObject dispatcherObject, System.Windows.Threading.DispatcherPriority priority) { } - public static System.IObservable ObserveOnDispatcher(this System.IObservable source) { } - public static System.IObservable ObserveOnDispatcher(this System.IObservable source, System.Windows.Threading.DispatcherPriority priority) { } - public static System.IObservable SubscribeOn(this System.IObservable source, System.Reactive.Concurrency.DispatcherScheduler scheduler) { } - public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Threading.Dispatcher dispatcher) { } - public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Threading.DispatcherObject dispatcherObject) { } - public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Threading.Dispatcher dispatcher, System.Windows.Threading.DispatcherPriority priority) { } - public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Threading.DispatcherObject dispatcherObject, System.Windows.Threading.DispatcherPriority priority) { } - public static System.IObservable SubscribeOnDispatcher(this System.IObservable source) { } - public static System.IObservable SubscribeOnDispatcher(this System.IObservable source, System.Windows.Threading.DispatcherPriority priority) { } - } public interface IGroupedObservable : System.IObservable { TKey Key { get; } @@ -2979,13 +2938,6 @@ public class QueryDebugger { public QueryDebugger() { } } - public static class RemotingObservable - { - public static System.IObservable Remotable(this System.IObservable source) { } - public static System.Reactive.Linq.IQbservable Remotable(this System.Reactive.Linq.IQbservable source) { } - public static System.IObservable Remotable(this System.IObservable source, System.Runtime.Remoting.Lifetime.ILease lease) { } - public static System.Reactive.Linq.IQbservable Remotable(this System.Reactive.Linq.IQbservable source, System.Runtime.Remoting.Lifetime.ILease lease) { } - } } namespace System.Reactive.PlatformServices { diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.LegacySystemReactive.verified.cs b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.LegacySystemReactive.verified.cs new file mode 100644 index 000000000..96d7950a7 --- /dev/null +++ b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.LegacySystemReactive.verified.cs @@ -0,0 +1,3196 @@ +[assembly: System.CLSCompliant(true)] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"System.Reactive, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"System.Reactive.Integration.Uwp, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"System.Reactive.Integration.Windows.Runtime, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Tests.System.Reactive, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Tests.System.Reactive.Uwp.DeviceRunner, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")] +[assembly: System.Runtime.InteropServices.ComVisible(false)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +namespace System +{ + public static class ObservableExtensions + { + public static System.IDisposable Subscribe(this System.IObservable source) { } + public static System.IDisposable Subscribe(this System.IObservable source, System.Action onNext) { } + public static void Subscribe(this System.IObservable source, System.Threading.CancellationToken token) { } + public static System.IDisposable Subscribe(this System.IObservable source, System.Action onNext, System.Action onCompleted) { } + public static System.IDisposable Subscribe(this System.IObservable source, System.Action onNext, System.Action onError) { } + public static void Subscribe(this System.IObservable source, System.Action onNext, System.Threading.CancellationToken token) { } + public static void Subscribe(this System.IObservable source, System.IObserver observer, System.Threading.CancellationToken token) { } + public static void Subscribe(this System.IObservable source, System.Action onNext, System.Action onCompleted, System.Threading.CancellationToken token) { } + public static System.IDisposable Subscribe(this System.IObservable source, System.Action onNext, System.Action onError, System.Action onCompleted) { } + public static void Subscribe(this System.IObservable source, System.Action onNext, System.Action onError, System.Threading.CancellationToken token) { } + public static void Subscribe(this System.IObservable source, System.Action onNext, System.Action onError, System.Action onCompleted, System.Threading.CancellationToken token) { } + public static System.IDisposable SubscribeSafe(this System.IObservable source, System.IObserver observer) { } + } +} +namespace System.Reactive +{ + public sealed class AnonymousObservable : System.Reactive.ObservableBase + { + public AnonymousObservable(System.Func, System.IDisposable> subscribe) { } + protected override System.IDisposable SubscribeCore(System.IObserver observer) { } + } + public sealed class AnonymousObserver : System.Reactive.ObserverBase + { + public AnonymousObserver(System.Action onNext) { } + public AnonymousObserver(System.Action onNext, System.Action onCompleted) { } + public AnonymousObserver(System.Action onNext, System.Action onError) { } + public AnonymousObserver(System.Action onNext, System.Action onError, System.Action onCompleted) { } + protected override void OnCompletedCore() { } + protected override void OnErrorCore(System.Exception error) { } + protected override void OnNextCore(T value) { } + } + public abstract class EventPatternSourceBase + { + protected EventPatternSourceBase(System.IObservable> source, System.Action, System.Reactive.EventPattern> invokeHandler) { } + protected void Add(System.Delegate handler, System.Action invoke) { } + protected void Remove(System.Delegate handler) { } + } + public class EventPattern : System.Reactive.EventPattern + { + public EventPattern(object? sender, TEventArgs e) { } + } + public class EventPattern : System.IEquatable>, System.Reactive.IEventPattern + { + public EventPattern(TSender? sender, TEventArgs e) { } + public TEventArgs EventArgs { get; } + public TSender Sender { get; } + public void Deconstruct(out TSender? sender, out TEventArgs e) { } + public bool Equals(System.Reactive.EventPattern? other) { } + public override bool Equals(object? obj) { } + public override int GetHashCode() { } + public static bool operator !=(System.Reactive.EventPattern first, System.Reactive.EventPattern second) { } + public static bool operator ==(System.Reactive.EventPattern first, System.Reactive.EventPattern second) { } + } + [System.AttributeUsage(System.AttributeTargets.All)] + [System.Reactive.Experimental] + public sealed class ExperimentalAttribute : System.Attribute + { + public ExperimentalAttribute() { } + } + public interface IEventPatternSource + { + event System.EventHandler OnNext; + } + public interface IEventPattern + { + TEventArgs EventArgs { get; } + TSender Sender { get; } + } + public interface IEventSource + { + event System.Action OnNext; + } + public interface IObserver + { + TResult OnCompleted(); + TResult OnError(System.Exception exception); + TResult OnNext(TValue value); + } + public interface ITaskObservableAwaiter : System.Runtime.CompilerServices.INotifyCompletion + { + bool IsCompleted { get; } + T GetResult(); + } + [System.Runtime.CompilerServices.AsyncMethodBuilder(typeof(System.Runtime.CompilerServices.TaskObservableMethodBuilder))] + public interface ITaskObservable : System.IObservable + { + System.Reactive.ITaskObservableAwaiter GetAwaiter(); + } + [System.Reactive.Experimental] + public class ListObservable : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.IEnumerable, System.IObservable + { + public ListObservable(System.IObservable source) { } + public int Count { get; } + public bool IsReadOnly { get; } + public T this[int index] { get; set; } + public T Value { get; } + public void Add(T item) { } + public void Clear() { } + public bool Contains(T item) { } + public void CopyTo(T[] array, int arrayIndex) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public int IndexOf(T item) { } + public void Insert(int index, T item) { } + public bool Remove(T item) { } + public void RemoveAt(int index) { } + public System.IDisposable Subscribe(System.IObserver observer) { } + } + public static class Notification + { + public static System.Reactive.Notification CreateOnCompleted() { } + public static System.Reactive.Notification CreateOnError(System.Exception error) { } + public static System.Reactive.Notification CreateOnNext(T value) { } + } + public enum NotificationKind + { + OnNext = 0, + OnError = 1, + OnCompleted = 2, + } + [System.Serializable] + public abstract class Notification : System.IEquatable> + { + protected Notification() { } + public abstract System.Exception? Exception { get; } + public abstract bool HasValue { get; } + public abstract System.Reactive.NotificationKind Kind { get; } + public abstract T Value { get; } + public abstract void Accept(System.IObserver observer); + public abstract void Accept(System.Action onNext, System.Action onError, System.Action onCompleted); + public abstract TResult Accept(System.Reactive.IObserver observer); + public abstract TResult Accept(System.Func onNext, System.Func onError, System.Func onCompleted); + public abstract bool Equals(System.Reactive.Notification? other); + public override bool Equals(object? obj) { } + public System.IObservable ToObservable() { } + public System.IObservable ToObservable(System.Reactive.Concurrency.IScheduler scheduler) { } + public static bool operator !=(System.Reactive.Notification left, System.Reactive.Notification right) { } + public static bool operator ==(System.Reactive.Notification left, System.Reactive.Notification right) { } + } + public abstract class ObservableBase : System.IObservable + { + protected ObservableBase() { } + public System.IDisposable Subscribe(System.IObserver observer) { } + protected abstract System.IDisposable SubscribeCore(System.IObserver observer); + } + public static class Observer + { + public static System.IObserver AsObserver(this System.IObserver observer) { } + public static System.IObserver Checked(this System.IObserver observer) { } + public static System.IObserver Create(System.Action onNext) { } + public static System.IObserver Create(System.Action onNext, System.Action onCompleted) { } + public static System.IObserver Create(System.Action onNext, System.Action onError) { } + public static System.IObserver Create(System.Action onNext, System.Action onError, System.Action onCompleted) { } + public static System.IObserver NotifyOn(this System.IObserver observer, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObserver NotifyOn(this System.IObserver observer, System.Threading.SynchronizationContext context) { } + public static System.IObserver Synchronize(System.IObserver observer) { } + public static System.IObserver Synchronize(System.IObserver observer, bool preventReentrancy) { } + public static System.IObserver Synchronize(System.IObserver observer, object gate) { } + public static System.IObserver Synchronize(System.IObserver observer, System.Reactive.Concurrency.AsyncLock asyncLock) { } + public static System.Action> ToNotifier(this System.IObserver observer) { } + public static System.IObserver ToObserver(this System.Action> handler) { } + public static System.IObserver ToObserver(this System.IProgress progress) { } + public static System.IProgress ToProgress(this System.IObserver observer) { } + public static System.IProgress ToProgress(this System.IObserver observer, System.Reactive.Concurrency.IScheduler scheduler) { } + } + public abstract class ObserverBase : System.IDisposable, System.IObserver + { + protected ObserverBase() { } + public void Dispose() { } + protected virtual void Dispose(bool disposing) { } + public void OnCompleted() { } + protected abstract void OnCompletedCore(); + public void OnError(System.Exception error) { } + protected abstract void OnErrorCore(System.Exception error); + public void OnNext(T value) { } + protected abstract void OnNextCore(T value); + } + [System.Serializable] + public readonly struct TimeInterval : System.IEquatable> + { + public TimeInterval(T value, System.TimeSpan interval) { } + public System.TimeSpan Interval { get; } + public T Value { get; } + public void Deconstruct(out T value, out System.TimeSpan interval) { } + public bool Equals(System.Reactive.TimeInterval other) { } + public override bool Equals(object? obj) { } + public override int GetHashCode() { } + public override string ToString() { } + public static bool operator !=(System.Reactive.TimeInterval first, System.Reactive.TimeInterval second) { } + public static bool operator ==(System.Reactive.TimeInterval first, System.Reactive.TimeInterval second) { } + } + public static class Timestamped + { + public static System.Reactive.Timestamped Create(T value, System.DateTimeOffset timestamp) { } + } + [System.Serializable] + public readonly struct Timestamped : System.IEquatable> + { + public Timestamped(T value, System.DateTimeOffset timestamp) { } + public System.DateTimeOffset Timestamp { get; } + public T Value { get; } + public void Deconstruct(out T value, out System.DateTimeOffset timestamp) { } + public bool Equals(System.Reactive.Timestamped other) { } + public override bool Equals(object? obj) { } + public override int GetHashCode() { } + public override string ToString() { } + public static bool operator !=(System.Reactive.Timestamped first, System.Reactive.Timestamped second) { } + public static bool operator ==(System.Reactive.Timestamped first, System.Reactive.Timestamped second) { } + } + [System.Serializable] + public readonly struct Unit : System.IEquatable + { + public static System.Reactive.Unit Default { get; } + public bool Equals(System.Reactive.Unit other) { } + public override bool Equals(object? obj) { } + public override int GetHashCode() { } + public override string ToString() { } + public static bool operator !=(System.Reactive.Unit first, System.Reactive.Unit second) { } + public static bool operator ==(System.Reactive.Unit first, System.Reactive.Unit second) { } + } +} +namespace System.Reactive.Concurrency +{ + public sealed class AsyncLock : System.IDisposable + { + public AsyncLock() { } + public void Dispose() { } + public void Wait(System.Action action) { } + } + public class ControlScheduler : System.Reactive.Concurrency.LocalScheduler, System.Reactive.Concurrency.ISchedulerPeriodic + { + public ControlScheduler(System.Windows.Forms.Control control) { } + public System.Windows.Forms.Control Control { get; } + public override System.IDisposable Schedule(TState state, System.Func action) { } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } + } + public sealed class CurrentThreadScheduler : System.Reactive.Concurrency.LocalScheduler + { + [System.Obsolete("This instance property is no longer supported. Use CurrentThreadScheduler.IsSched" + + "uleRequired instead.")] + public bool ScheduleRequired { get; } + public static System.Reactive.Concurrency.CurrentThreadScheduler Instance { get; } + public static bool IsScheduleRequired { get; } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + } + public sealed class DefaultScheduler : System.Reactive.Concurrency.LocalScheduler, System.Reactive.Concurrency.ISchedulerPeriodic + { + public static System.Reactive.Concurrency.DefaultScheduler Instance { get; } + protected override object? GetService(System.Type serviceType) { } + public override System.IDisposable Schedule(TState state, System.Func action) { } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } + } + public class DispatcherScheduler : System.Reactive.Concurrency.LocalScheduler, System.Reactive.Concurrency.ISchedulerPeriodic + { + public DispatcherScheduler(System.Windows.Threading.Dispatcher dispatcher) { } + public DispatcherScheduler(System.Windows.Threading.Dispatcher dispatcher, System.Windows.Threading.DispatcherPriority priority) { } + public System.Windows.Threading.Dispatcher Dispatcher { get; } + public System.Windows.Threading.DispatcherPriority Priority { get; } + public static System.Reactive.Concurrency.DispatcherScheduler Current { get; } + [System.Obsolete("Use the Current property to retrieve the DispatcherScheduler instance for the cur" + + "rent thread\'s Dispatcher object.")] + public static System.Reactive.Concurrency.DispatcherScheduler Instance { get; } + public override System.IDisposable Schedule(TState state, System.Func action) { } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } + } + public sealed class EventLoopScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic + { + public EventLoopScheduler() { } + public EventLoopScheduler(System.Func threadFactory) { } + public void Dispose() { } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } + public override System.Reactive.Concurrency.IStopwatch StartStopwatch() { } + } + [System.Diagnostics.DebuggerDisplay("\\{ Clock = {Clock} Now = {Now.ToString(\"O\")} \\}")] + public class HistoricalScheduler : System.Reactive.Concurrency.HistoricalSchedulerBase + { + public HistoricalScheduler() { } + public HistoricalScheduler(System.DateTimeOffset initialClock) { } + public HistoricalScheduler(System.DateTimeOffset initialClock, System.Collections.Generic.IComparer comparer) { } + protected override System.Reactive.Concurrency.IScheduledItem? GetNext() { } + public override System.IDisposable ScheduleAbsolute(TState state, System.DateTimeOffset dueTime, System.Func action) { } + } + public abstract class HistoricalSchedulerBase : System.Reactive.Concurrency.VirtualTimeSchedulerBase + { + protected HistoricalSchedulerBase() { } + protected HistoricalSchedulerBase(System.DateTimeOffset initialClock) { } + protected HistoricalSchedulerBase(System.DateTimeOffset initialClock, System.Collections.Generic.IComparer comparer) { } + protected override System.DateTimeOffset Add(System.DateTimeOffset absolute, System.TimeSpan relative) { } + protected override System.DateTimeOffset ToDateTimeOffset(System.DateTimeOffset absolute) { } + protected override System.TimeSpan ToRelative(System.TimeSpan timeSpan) { } + } + public interface IConcurrencyAbstractionLayer + { + bool SupportsLongRunning { get; } + System.IDisposable QueueUserWorkItem(System.Action action, object? state); + void Sleep(System.TimeSpan timeout); + System.IDisposable StartPeriodicTimer(System.Action action, System.TimeSpan period); + System.Reactive.Concurrency.IStopwatch StartStopwatch(); + void StartThread(System.Action action, object? state); + System.IDisposable StartTimer(System.Action action, object? state, System.TimeSpan dueTime); + } + public interface IScheduledItem + { + TAbsolute DueTime { get; } + void Invoke(); + } + public interface IScheduler + { + System.DateTimeOffset Now { get; } + System.IDisposable Schedule(TState state, System.Func action); + System.IDisposable Schedule(TState state, System.DateTimeOffset dueTime, System.Func action); + System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action); + } + public interface ISchedulerLongRunning + { + System.IDisposable ScheduleLongRunning(TState state, System.Action action); + } + public interface ISchedulerPeriodic + { + System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action); + } + public interface IStopwatch + { + System.TimeSpan Elapsed { get; } + } + public interface IStopwatchProvider + { + System.Reactive.Concurrency.IStopwatch StartStopwatch(); + } + public sealed class ImmediateScheduler : System.Reactive.Concurrency.LocalScheduler + { + public static System.Reactive.Concurrency.ImmediateScheduler Instance { get; } + public override System.IDisposable Schedule(TState state, System.Func action) { } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + } + public abstract class LocalScheduler : System.IServiceProvider, System.Reactive.Concurrency.IScheduler, System.Reactive.Concurrency.IStopwatchProvider + { + protected LocalScheduler() { } + public virtual System.DateTimeOffset Now { get; } + protected virtual object? GetService(System.Type serviceType) { } + public virtual System.IDisposable Schedule(TState state, System.Func action) { } + public virtual System.IDisposable Schedule(TState state, System.DateTimeOffset dueTime, System.Func action) { } + public abstract System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action); + public virtual System.Reactive.Concurrency.IStopwatch StartStopwatch() { } + } + public sealed class NewThreadScheduler : System.Reactive.Concurrency.LocalScheduler, System.Reactive.Concurrency.ISchedulerLongRunning, System.Reactive.Concurrency.ISchedulerPeriodic + { + public NewThreadScheduler() { } + public NewThreadScheduler(System.Func threadFactory) { } + public static System.Reactive.Concurrency.NewThreadScheduler Default { get; } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + public System.IDisposable ScheduleLongRunning(TState state, System.Action action) { } + public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } + public override System.Reactive.Concurrency.IStopwatch StartStopwatch() { } + } + public abstract class ScheduledItem : System.IComparable>, System.IDisposable, System.Reactive.Concurrency.IScheduledItem + where TAbsolute : System.IComparable + { + protected ScheduledItem(TAbsolute dueTime, System.Collections.Generic.IComparer comparer) { } + public TAbsolute DueTime { get; } + public bool IsCanceled { get; } + public void Cancel() { } + public int CompareTo(System.Reactive.Concurrency.ScheduledItem? other) { } + public override bool Equals(object? obj) { } + public override int GetHashCode() { } + public void Invoke() { } + protected abstract System.IDisposable InvokeCore(); + public static bool operator !=(System.Reactive.Concurrency.ScheduledItem? left, System.Reactive.Concurrency.ScheduledItem? right) { } + public static bool operator <(System.Reactive.Concurrency.ScheduledItem left, System.Reactive.Concurrency.ScheduledItem right) { } + public static bool operator <=(System.Reactive.Concurrency.ScheduledItem left, System.Reactive.Concurrency.ScheduledItem right) { } + public static bool operator ==(System.Reactive.Concurrency.ScheduledItem? left, System.Reactive.Concurrency.ScheduledItem? right) { } + public static bool operator >(System.Reactive.Concurrency.ScheduledItem left, System.Reactive.Concurrency.ScheduledItem right) { } + public static bool operator >=(System.Reactive.Concurrency.ScheduledItem left, System.Reactive.Concurrency.ScheduledItem right) { } + } + public sealed class ScheduledItem : System.Reactive.Concurrency.ScheduledItem + where TAbsolute : System.IComparable + { + public ScheduledItem(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func action, TAbsolute dueTime) { } + public ScheduledItem(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func action, TAbsolute dueTime, System.Collections.Generic.IComparer comparer) { } + protected override System.IDisposable InvokeCore() { } + } + public static class Scheduler + { + public static System.Reactive.Concurrency.CurrentThreadScheduler CurrentThread { get; } + public static System.Reactive.Concurrency.DefaultScheduler Default { get; } + public static System.Reactive.Concurrency.ImmediateScheduler Immediate { get; } + [System.Obsolete("This property is no longer supported due to refactoring of the API surface and el" + + "imination of platform-specific dependencies. Please use NewThreadScheduler.Defau" + + "lt to obtain an instance of this scheduler type.")] + public static System.Reactive.Concurrency.IScheduler NewThread { get; } + public static System.DateTimeOffset Now { get; } + [System.Obsolete("This property is no longer supported due to refactoring of the API surface and el" + + "imination of platform-specific dependencies. Please use TaskPoolScheduler.Defaul" + + "t to obtain an instance of this scheduler type.")] + public static System.Reactive.Concurrency.IScheduler TaskPool { get; } + [System.Obsolete(@"This property is no longer supported due to refactoring of the API surface and elimination of platform-specific dependencies. Consider using Scheduler.Default to obtain the platform's most appropriate pool-based scheduler. In order to access a specific pool-based scheduler, please add a reference to the System.Reactive.PlatformServices assembly for your target platform and use the appropriate scheduler in the System.Reactive.Concurrency namespace.")] + public static System.Reactive.Concurrency.IScheduler ThreadPool { get; } + public static System.Reactive.Concurrency.ISchedulerLongRunning? AsLongRunning(this System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Concurrency.ISchedulerPeriodic? AsPeriodic(this System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Concurrency.IStopwatchProvider? AsStopwatchProvider(this System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Concurrency.IScheduler Catch(this System.Reactive.Concurrency.IScheduler scheduler, System.Func handler) + where TException : System.Exception { } + public static System.Reactive.Concurrency.IScheduler DisableOptimizations(this System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Concurrency.IScheduler DisableOptimizations(this System.Reactive.Concurrency.IScheduler scheduler, params System.Type[] optimizationInterfaces) { } + public static System.TimeSpan Normalize(System.TimeSpan timeSpan) { } + public static System.IDisposable Schedule(this System.Reactive.Concurrency.IScheduler scheduler, System.Action action) { } + public static System.IDisposable Schedule(this System.Reactive.Concurrency.IScheduler scheduler, System.Action action) { } + public static System.IDisposable Schedule(this System.Reactive.Concurrency.IScheduler scheduler, System.DateTimeOffset dueTime, System.Action action) { } + public static System.IDisposable Schedule(this System.Reactive.Concurrency.IScheduler scheduler, System.DateTimeOffset dueTime, System.Action> action) { } + public static System.IDisposable Schedule(this System.Reactive.Concurrency.IScheduler scheduler, System.TimeSpan dueTime, System.Action action) { } + public static System.IDisposable Schedule(this System.Reactive.Concurrency.IScheduler scheduler, System.TimeSpan dueTime, System.Action> action) { } + public static System.IDisposable Schedule(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.Action> action) { } + public static System.IDisposable Schedule(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.DateTimeOffset dueTime, System.Action> action) { } + public static System.IDisposable Schedule(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.TimeSpan dueTime, System.Action> action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, System.Func action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, System.Func> action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, System.DateTimeOffset dueTime, System.Func action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, System.DateTimeOffset dueTime, System.Func> action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, System.TimeSpan dueTime, System.Func action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, System.TimeSpan dueTime, System.Func> action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.Func action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.Func> action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.DateTimeOffset dueTime, System.Func action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.DateTimeOffset dueTime, System.Func> action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.TimeSpan dueTime, System.Func action) { } + public static System.IDisposable ScheduleAsync(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.TimeSpan dueTime, System.Func> action) { } + public static System.IDisposable ScheduleLongRunning(this System.Reactive.Concurrency.ISchedulerLongRunning scheduler, System.Action action) { } + public static System.IDisposable SchedulePeriodic(this System.Reactive.Concurrency.IScheduler scheduler, System.TimeSpan period, System.Action action) { } + public static System.IDisposable SchedulePeriodic(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.TimeSpan period, System.Action action) { } + public static System.IDisposable SchedulePeriodic(this System.Reactive.Concurrency.IScheduler scheduler, TState state, System.TimeSpan period, System.Func action) { } + public static System.Reactive.Concurrency.SchedulerOperation Sleep(this System.Reactive.Concurrency.IScheduler scheduler, System.DateTimeOffset dueTime) { } + public static System.Reactive.Concurrency.SchedulerOperation Sleep(this System.Reactive.Concurrency.IScheduler scheduler, System.TimeSpan dueTime) { } + public static System.Reactive.Concurrency.SchedulerOperation Sleep(this System.Reactive.Concurrency.IScheduler scheduler, System.DateTimeOffset dueTime, System.Threading.CancellationToken cancellationToken) { } + public static System.Reactive.Concurrency.SchedulerOperation Sleep(this System.Reactive.Concurrency.IScheduler scheduler, System.TimeSpan dueTime, System.Threading.CancellationToken cancellationToken) { } + public static System.Reactive.Concurrency.IStopwatch StartStopwatch(this System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Concurrency.SchedulerOperation Yield(this System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Concurrency.SchedulerOperation Yield(this System.Reactive.Concurrency.IScheduler scheduler, System.Threading.CancellationToken cancellationToken) { } + } + public sealed class SchedulerOperation + { + public System.Reactive.Concurrency.SchedulerOperation ConfigureAwait(bool continueOnCapturedContext) { } + public System.Reactive.Concurrency.SchedulerOperationAwaiter GetAwaiter() { } + } + public sealed class SchedulerOperationAwaiter : System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get; } + public void GetResult() { } + public void OnCompleted(System.Action continuation) { } + } + public class SchedulerQueue + where TAbsolute : System.IComparable + { + public SchedulerQueue() { } + public SchedulerQueue(int capacity) { } + public int Count { get; } + public System.Reactive.Concurrency.ScheduledItem Dequeue() { } + public void Enqueue(System.Reactive.Concurrency.ScheduledItem scheduledItem) { } + public System.Reactive.Concurrency.ScheduledItem Peek() { } + public bool Remove(System.Reactive.Concurrency.ScheduledItem scheduledItem) { } + } + public static class Synchronization + { + public static System.IObservable ObserveOn(System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable ObserveOn(System.IObservable source, System.Threading.SynchronizationContext context) { } + public static System.IObservable SubscribeOn(System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable SubscribeOn(System.IObservable source, System.Threading.SynchronizationContext context) { } + public static System.IObservable Synchronize(System.IObservable source) { } + public static System.IObservable Synchronize(System.IObservable source, object gate) { } + } + public class SynchronizationContextScheduler : System.Reactive.Concurrency.LocalScheduler + { + public SynchronizationContextScheduler(System.Threading.SynchronizationContext context) { } + public SynchronizationContextScheduler(System.Threading.SynchronizationContext context, bool alwaysPost) { } + public override System.IDisposable Schedule(TState state, System.Func action) { } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + } + public sealed class TaskObservationOptions + { + public TaskObservationOptions(System.Reactive.Concurrency.IScheduler? scheduler, bool ignoreExceptionsAfterUnsubscribe) { } + public bool IgnoreExceptionsAfterUnsubscribe { get; } + public System.Reactive.Concurrency.IScheduler? Scheduler { get; } + } + public sealed class TaskPoolScheduler : System.Reactive.Concurrency.LocalScheduler, System.Reactive.Concurrency.ISchedulerLongRunning, System.Reactive.Concurrency.ISchedulerPeriodic + { + public TaskPoolScheduler(System.Threading.Tasks.TaskFactory taskFactory) { } + public static System.Reactive.Concurrency.TaskPoolScheduler Default { get; } + public override System.IDisposable Schedule(TState state, System.Func action) { } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + public System.IDisposable ScheduleLongRunning(TState state, System.Action action) { } + public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } + public override System.Reactive.Concurrency.IStopwatch StartStopwatch() { } + } + public sealed class ThreadPoolScheduler : System.Reactive.Concurrency.LocalScheduler, System.Reactive.Concurrency.ISchedulerLongRunning, System.Reactive.Concurrency.ISchedulerPeriodic + { + public static System.Reactive.Concurrency.ThreadPoolScheduler Instance { get; } + public override System.IDisposable Schedule(TState state, System.Func action) { } + public override System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + public System.IDisposable ScheduleLongRunning(TState state, System.Action action) { } + public System.IDisposable SchedulePeriodic(TState state, System.TimeSpan period, System.Func action) { } + public override System.Reactive.Concurrency.IStopwatch StartStopwatch() { } + } + public abstract class VirtualTimeSchedulerBase : System.IServiceProvider, System.Reactive.Concurrency.IScheduler, System.Reactive.Concurrency.IStopwatchProvider + where TAbsolute : System.IComparable + { + protected VirtualTimeSchedulerBase() { } + protected VirtualTimeSchedulerBase(TAbsolute initialClock, System.Collections.Generic.IComparer comparer) { } + public TAbsolute Clock { get; set; } + protected System.Collections.Generic.IComparer Comparer { get; } + public bool IsEnabled { get; } + public System.DateTimeOffset Now { get; } + protected abstract TAbsolute Add(TAbsolute absolute, TRelative relative); + public void AdvanceBy(TRelative time) { } + public void AdvanceTo(TAbsolute time) { } + protected abstract System.Reactive.Concurrency.IScheduledItem? GetNext(); + protected virtual object? GetService(System.Type serviceType) { } + public System.IDisposable Schedule(TState state, System.Func action) { } + public System.IDisposable Schedule(TState state, System.DateTimeOffset dueTime, System.Func action) { } + public System.IDisposable Schedule(TState state, System.TimeSpan dueTime, System.Func action) { } + public abstract System.IDisposable ScheduleAbsolute(TState state, TAbsolute dueTime, System.Func action); + public System.IDisposable ScheduleRelative(TState state, TRelative dueTime, System.Func action) { } + public void Sleep(TRelative time) { } + public void Start() { } + public System.Reactive.Concurrency.IStopwatch StartStopwatch() { } + public void Stop() { } + protected abstract System.DateTimeOffset ToDateTimeOffset(TAbsolute absolute); + protected abstract TRelative ToRelative(System.TimeSpan timeSpan); + } + public static class VirtualTimeSchedulerExtensions + { + public static System.IDisposable ScheduleAbsolute(this System.Reactive.Concurrency.VirtualTimeSchedulerBase scheduler, TAbsolute dueTime, System.Action action) + where TAbsolute : System.IComparable { } + public static System.IDisposable ScheduleRelative(this System.Reactive.Concurrency.VirtualTimeSchedulerBase scheduler, TRelative dueTime, System.Action action) + where TAbsolute : System.IComparable { } + } + public abstract class VirtualTimeScheduler : System.Reactive.Concurrency.VirtualTimeSchedulerBase + where TAbsolute : System.IComparable + { + protected VirtualTimeScheduler() { } + protected VirtualTimeScheduler(TAbsolute initialClock, System.Collections.Generic.IComparer comparer) { } + protected override System.Reactive.Concurrency.IScheduledItem? GetNext() { } + public override System.IDisposable ScheduleAbsolute(TState state, TAbsolute dueTime, System.Func action) { } + } +} +namespace System.Reactive.Disposables +{ + public sealed class BooleanDisposable : System.IDisposable, System.Reactive.Disposables.ICancelable + { + public BooleanDisposable() { } + public bool IsDisposed { get; } + public void Dispose() { } + } + public sealed class CancellationDisposable : System.IDisposable, System.Reactive.Disposables.ICancelable + { + public CancellationDisposable() { } + public CancellationDisposable(System.Threading.CancellationTokenSource cts) { } + public bool IsDisposed { get; } + public System.Threading.CancellationToken Token { get; } + public void Dispose() { } + } + public sealed class CompositeDisposable : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable, System.Reactive.Disposables.ICancelable + { + public CompositeDisposable() { } + public CompositeDisposable(System.Collections.Generic.IEnumerable disposables) { } + public CompositeDisposable(params System.IDisposable[] disposables) { } + public CompositeDisposable(int capacity) { } + public int Count { get; } + public bool IsDisposed { get; } + public bool IsReadOnly { get; } + public void Add(System.IDisposable item) { } + public void Clear() { } + public bool Contains(System.IDisposable item) { } + public void CopyTo(System.IDisposable[] array, int arrayIndex) { } + public void Dispose() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public bool Remove(System.IDisposable item) { } + } + public sealed class ContextDisposable : System.IDisposable, System.Reactive.Disposables.ICancelable + { + public ContextDisposable(System.Threading.SynchronizationContext context, System.IDisposable disposable) { } + public System.Threading.SynchronizationContext Context { get; } + public bool IsDisposed { get; } + public void Dispose() { } + } + public static class Disposable + { + public static System.IDisposable Empty { get; } + public static System.IDisposable Create(System.Action dispose) { } + public static System.IDisposable Create(TState state, System.Action dispose) { } + } + public interface ICancelable : System.IDisposable + { + bool IsDisposed { get; } + } + public sealed class MultipleAssignmentDisposable : System.IDisposable, System.Reactive.Disposables.ICancelable + { + public MultipleAssignmentDisposable() { } + public System.IDisposable? Disposable { get; set; } + public bool IsDisposed { get; } + public void Dispose() { } + } + public sealed class RefCountDisposable : System.IDisposable, System.Reactive.Disposables.ICancelable + { + public RefCountDisposable(System.IDisposable disposable) { } + public RefCountDisposable(System.IDisposable disposable, bool throwWhenDisposed) { } + public bool IsDisposed { get; } + public void Dispose() { } + public System.IDisposable GetDisposable() { } + } + public sealed class ScheduledDisposable : System.IDisposable, System.Reactive.Disposables.ICancelable + { + public ScheduledDisposable(System.Reactive.Concurrency.IScheduler scheduler, System.IDisposable disposable) { } + public System.IDisposable Disposable { get; } + public bool IsDisposed { get; } + public System.Reactive.Concurrency.IScheduler Scheduler { get; } + public void Dispose() { } + } + public sealed class SerialDisposable : System.IDisposable, System.Reactive.Disposables.ICancelable + { + public SerialDisposable() { } + public System.IDisposable? Disposable { get; set; } + public bool IsDisposed { get; } + public void Dispose() { } + } + public sealed class SingleAssignmentDisposable : System.IDisposable, System.Reactive.Disposables.ICancelable + { + public SingleAssignmentDisposable() { } + public System.IDisposable? Disposable { get; set; } + public bool IsDisposed { get; } + public void Dispose() { } + } + public struct SingleAssignmentDisposableValue + { + public System.IDisposable? Disposable { get; set; } + public bool IsDisposed { get; } + public void Dispose() { } + public override bool Equals(object? obj) { } + public override int GetHashCode() { } + public static bool operator !=(System.Reactive.Disposables.SingleAssignmentDisposableValue left, System.Reactive.Disposables.SingleAssignmentDisposableValue right) { } + public static bool operator ==(System.Reactive.Disposables.SingleAssignmentDisposableValue left, System.Reactive.Disposables.SingleAssignmentDisposableValue right) { } + } + public abstract class StableCompositeDisposable : System.IDisposable, System.Reactive.Disposables.ICancelable + { + protected StableCompositeDisposable() { } + public abstract bool IsDisposed { get; } + public abstract void Dispose(); + public static System.Reactive.Disposables.ICancelable Create(System.Collections.Generic.IEnumerable disposables) { } + public static System.Reactive.Disposables.ICancelable Create(params System.IDisposable[] disposables) { } + public static System.Reactive.Disposables.ICancelable Create(System.IDisposable disposable1, System.IDisposable disposable2) { } + } +} +namespace System.Reactive.Joins +{ + public abstract class Pattern { } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public class Pattern : System.Reactive.Joins.Pattern + { + public System.Reactive.Joins.Pattern And(System.IObservable other) { } + public System.Reactive.Joins.Plan Then(System.Func selector) { } + } + public abstract class Plan { } + public abstract class QueryablePattern + { + protected QueryablePattern(System.Linq.Expressions.Expression expression) { } + public System.Linq.Expressions.Expression Expression { get; } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePattern : System.Reactive.Joins.QueryablePattern + { + public System.Reactive.Joins.QueryablePattern And(System.IObservable other) { } + public System.Reactive.Joins.QueryablePlan Then(System.Linq.Expressions.Expression> selector) { } + } + public class QueryablePlan + { + public System.Linq.Expressions.Expression Expression { get; } + } +} +namespace System.Reactive.Linq +{ + public static class ControlObservable + { + public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Forms.Control control) { } + public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Forms.Control control) { } + } + public static class DispatcherObservable + { + public static System.IObservable ObserveOn(this System.IObservable source, System.Reactive.Concurrency.DispatcherScheduler scheduler) { } + public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Threading.Dispatcher dispatcher) { } + public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Threading.DispatcherObject dispatcherObject) { } + public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Threading.Dispatcher dispatcher, System.Windows.Threading.DispatcherPriority priority) { } + public static System.IObservable ObserveOn(this System.IObservable source, System.Windows.Threading.DispatcherObject dispatcherObject, System.Windows.Threading.DispatcherPriority priority) { } + public static System.IObservable ObserveOnDispatcher(this System.IObservable source) { } + public static System.IObservable ObserveOnDispatcher(this System.IObservable source, System.Windows.Threading.DispatcherPriority priority) { } + public static System.IObservable SubscribeOn(this System.IObservable source, System.Reactive.Concurrency.DispatcherScheduler scheduler) { } + public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Threading.Dispatcher dispatcher) { } + public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Threading.DispatcherObject dispatcherObject) { } + public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Threading.Dispatcher dispatcher, System.Windows.Threading.DispatcherPriority priority) { } + public static System.IObservable SubscribeOn(this System.IObservable source, System.Windows.Threading.DispatcherObject dispatcherObject, System.Windows.Threading.DispatcherPriority priority) { } + public static System.IObservable SubscribeOnDispatcher(this System.IObservable source) { } + public static System.IObservable SubscribeOnDispatcher(this System.IObservable source, System.Windows.Threading.DispatcherPriority priority) { } + } + public interface IGroupedObservable : System.IObservable + { + TKey Key { get; } + } + public interface IQbservable + { + System.Type ElementType { get; } + System.Linq.Expressions.Expression Expression { get; } + System.Reactive.Linq.IQbservableProvider Provider { get; } + } + public interface IQbservableProvider + { + System.Reactive.Linq.IQbservable CreateQuery(System.Linq.Expressions.Expression expression); + } + public interface IQbservable : System.IObservable, System.Reactive.Linq.IQbservable { } + [System.AttributeUsage(System.AttributeTargets.Class, Inherited=false)] + public sealed class LocalQueryMethodImplementationTypeAttribute : System.Attribute + { + public LocalQueryMethodImplementationTypeAttribute(System.Type targetType) { } + public System.Type TargetType { get; } + } + public static class Observable + { + public static System.IObservable Aggregate(this System.IObservable source, System.Func accumulator) { } + public static System.IObservable Aggregate(this System.IObservable source, TAccumulate seed, System.Func accumulator) { } + public static System.IObservable Aggregate(this System.IObservable source, TAccumulate seed, System.Func accumulator, System.Func resultSelector) { } + public static System.IObservable All(this System.IObservable source, System.Func predicate) { } + public static System.IObservable Amb(params System.IObservable[] sources) { } + public static System.IObservable Amb(this System.Collections.Generic.IEnumerable> sources) { } + public static System.IObservable Amb(this System.IObservable first, System.IObservable second) { } + public static System.Reactive.Joins.Pattern And(this System.IObservable left, System.IObservable right) { } + public static System.IObservable Any(this System.IObservable source) { } + public static System.IObservable Any(this System.IObservable source, System.Func predicate) { } + public static System.IObservable Append(this System.IObservable source, TSource value) { } + public static System.IObservable Append(this System.IObservable source, TSource value, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable AsObservable(this System.IObservable source) { } + public static System.IObservable AutoConnect(this System.Reactive.Subjects.IConnectableObservable source, int minObservers = 1, System.Action? onConnect = null) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable Average(this System.IObservable source, System.Func selector) { } + public static System.IObservable> Buffer(this System.IObservable source, int count) { } + public static System.IObservable> Buffer(this System.IObservable source, System.TimeSpan timeSpan) { } + public static System.IObservable> Buffer(this System.IObservable source, int count, int skip) { } + public static System.IObservable> Buffer(this System.IObservable source, System.TimeSpan timeSpan, int count) { } + public static System.IObservable> Buffer(this System.IObservable source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> Buffer(this System.IObservable source, System.TimeSpan timeSpan, System.TimeSpan timeShift) { } + public static System.IObservable> Buffer(this System.IObservable source, System.TimeSpan timeSpan, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> Buffer(this System.IObservable source, System.TimeSpan timeSpan, System.TimeSpan timeShift, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> Buffer(this System.IObservable source, System.Func> bufferClosingSelector) { } + public static System.IObservable> Buffer(this System.IObservable source, System.IObservable bufferBoundaries) { } + public static System.IObservable> Buffer(this System.IObservable source, System.IObservable bufferOpenings, System.Func> bufferClosingSelector) { } + public static System.IObservable Case(System.Func selector, System.Collections.Generic.IDictionary> sources) + where TValue : notnull { } + public static System.IObservable Case(System.Func selector, System.Collections.Generic.IDictionary> sources, System.IObservable defaultSource) + where TValue : notnull { } + public static System.IObservable Case(System.Func selector, System.Collections.Generic.IDictionary> sources, System.Reactive.Concurrency.IScheduler scheduler) + where TValue : notnull { } + public static System.IObservable Cast(this System.IObservable source) { } + public static System.IObservable Catch(params System.IObservable[] sources) { } + public static System.IObservable Catch(this System.Collections.Generic.IEnumerable> sources) { } + public static System.IObservable Catch(this System.IObservable first, System.IObservable second) { } + public static System.IObservable Catch(this System.IObservable source, System.Func> handler) + where TException : System.Exception { } + public static System.Collections.Generic.IEnumerable> Chunkify(this System.IObservable source) { } + public static System.Collections.Generic.IEnumerable Collect(this System.IObservable source, System.Func newCollector, System.Func merge) { } + public static System.Collections.Generic.IEnumerable Collect(this System.IObservable source, System.Func getInitialCollector, System.Func merge, System.Func getNewCollector) { } + public static System.IObservable> CombineLatest(params System.IObservable[] sources) { } + public static System.IObservable> CombineLatest(this System.Collections.Generic.IEnumerable> sources) { } + public static System.IObservable CombineLatest(this System.Collections.Generic.IEnumerable> sources, System.Func, TResult> resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable first, System.IObservable second, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.IObservable source13, System.Func resultSelector) { } + public static System.IObservable CombineLatest(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.IObservable source13, System.IObservable source14, System.Func resultSelector) { } + public static System.IObservable CombineLatest( + this System.IObservable source1, + System.IObservable source2, + System.IObservable source3, + System.IObservable source4, + System.IObservable source5, + System.IObservable source6, + System.IObservable source7, + System.IObservable source8, + System.IObservable source9, + System.IObservable source10, + System.IObservable source11, + System.IObservable source12, + System.IObservable source13, + System.IObservable source14, + System.IObservable source15, + System.Func resultSelector) { } + public static System.IObservable CombineLatest( + this System.IObservable source1, + System.IObservable source2, + System.IObservable source3, + System.IObservable source4, + System.IObservable source5, + System.IObservable source6, + System.IObservable source7, + System.IObservable source8, + System.IObservable source9, + System.IObservable source10, + System.IObservable source11, + System.IObservable source12, + System.IObservable source13, + System.IObservable source14, + System.IObservable source15, + System.IObservable source16, + System.Func resultSelector) { } + public static System.IObservable Concat(params System.IObservable[] sources) { } + public static System.IObservable Concat(this System.Collections.Generic.IEnumerable> sources) { } + public static System.IObservable Concat(this System.IObservable> sources) { } + public static System.IObservable Concat(this System.IObservable> sources) { } + public static System.IObservable Concat(this System.IObservable first, System.IObservable second) { } + public static System.IObservable Contains(this System.IObservable source, TSource value) { } + public static System.IObservable Contains(this System.IObservable source, TSource value, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable Count(this System.IObservable source) { } + public static System.IObservable Count(this System.IObservable source, System.Func predicate) { } + public static System.IObservable Create(System.Func, System.Action> subscribe) { } + public static System.IObservable Create(System.Func, System.IDisposable> subscribe) { } + public static System.IObservable Create(System.Func, System.Threading.Tasks.Task> subscribeAsync) { } + public static System.IObservable Create(System.Func, System.Threading.Tasks.Task> subscribeAsync) { } + public static System.IObservable Create(System.Func, System.Threading.Tasks.Task> subscribeAsync) { } + public static System.IObservable Create(System.Func, System.Threading.CancellationToken, System.Threading.Tasks.Task> subscribeAsync) { } + public static System.IObservable Create(System.Func, System.Threading.CancellationToken, System.Threading.Tasks.Task> subscribeAsync) { } + public static System.IObservable Create(System.Func, System.Threading.CancellationToken, System.Threading.Tasks.Task> subscribeAsync) { } + public static System.IObservable DefaultIfEmpty(this System.IObservable source) { } + public static System.IObservable DefaultIfEmpty(this System.IObservable source, TSource defaultValue) { } + public static System.IObservable Defer(System.Func> observableFactory) { } + public static System.IObservable Defer(System.Func>> observableFactoryAsync) { } + public static System.IObservable Defer(System.Func>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe) { } + public static System.IObservable DeferAsync(System.Func>> observableFactoryAsync) { } + public static System.IObservable DeferAsync(System.Func>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe) { } + public static System.IObservable Delay(this System.IObservable source, System.DateTimeOffset dueTime) { } + public static System.IObservable Delay(this System.IObservable source, System.TimeSpan dueTime) { } + public static System.IObservable Delay(this System.IObservable source, System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Delay(this System.IObservable source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Delay(this System.IObservable source, System.Func> delayDurationSelector) { } + public static System.IObservable Delay(this System.IObservable source, System.IObservable subscriptionDelay, System.Func> delayDurationSelector) { } + public static System.IObservable DelaySubscription(this System.IObservable source, System.DateTimeOffset dueTime) { } + public static System.IObservable DelaySubscription(this System.IObservable source, System.TimeSpan dueTime) { } + public static System.IObservable DelaySubscription(this System.IObservable source, System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable DelaySubscription(this System.IObservable source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Dematerialize(this System.IObservable> source) { } + public static System.IObservable Distinct(this System.IObservable source) { } + public static System.IObservable Distinct(this System.IObservable source, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable Distinct(this System.IObservable source, System.Func keySelector) { } + public static System.IObservable Distinct(this System.IObservable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable DistinctUntilChanged(this System.IObservable source) { } + public static System.IObservable DistinctUntilChanged(this System.IObservable source, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable DistinctUntilChanged(this System.IObservable source, System.Func keySelector) { } + public static System.IObservable DistinctUntilChanged(this System.IObservable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable Do(this System.IObservable source, System.Action onNext) { } + public static System.IObservable Do(this System.IObservable source, System.IObserver observer) { } + public static System.IObservable Do(this System.IObservable source, System.Action onNext, System.Action onCompleted) { } + public static System.IObservable Do(this System.IObservable source, System.Action onNext, System.Action onError) { } + public static System.IObservable Do(this System.IObservable source, System.Action onNext, System.Action onError, System.Action onCompleted) { } + public static System.IObservable DoWhile(this System.IObservable source, System.Func condition) { } + public static System.IObservable ElementAt(this System.IObservable source, int index) { } + public static System.IObservable ElementAtOrDefault(this System.IObservable source, int index) { } + public static System.IObservable Empty() { } + public static System.IObservable Empty(System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Empty(TResult witness) { } + public static System.IObservable Empty(System.Reactive.Concurrency.IScheduler scheduler, TResult witness) { } + public static System.IObservable Finally(this System.IObservable source, System.Action finallyAction) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + public static TSource First(this System.IObservable source) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + public static TSource First(this System.IObservable source, System.Func predicate) { } + public static System.IObservable FirstAsync(this System.IObservable source) { } + public static System.IObservable FirstAsync(this System.IObservable source, System.Func predicate) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + [return: System.Diagnostics.CodeAnalysis.MaybeNull] + public static TSource FirstOrDefault(this System.IObservable source) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + [return: System.Diagnostics.CodeAnalysis.MaybeNull] + public static TSource FirstOrDefault(this System.IObservable source, System.Func predicate) { } + public static System.IObservable FirstOrDefaultAsync(this System.IObservable source) { } + public static System.IObservable FirstOrDefaultAsync(this System.IObservable source, System.Func predicate) { } + public static System.IObservable For(System.Collections.Generic.IEnumerable source, System.Func> resultSelector) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + public static void ForEach(this System.IObservable source, System.Action onNext) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + public static void ForEach(this System.IObservable source, System.Action onNext) { } + public static System.Threading.Tasks.Task ForEachAsync(this System.IObservable source, System.Action onNext) { } + public static System.Threading.Tasks.Task ForEachAsync(this System.IObservable source, System.Action onNext) { } + public static System.Threading.Tasks.Task ForEachAsync(this System.IObservable source, System.Action onNext, System.Threading.CancellationToken cancellationToken) { } + public static System.Threading.Tasks.Task ForEachAsync(this System.IObservable source, System.Action onNext, System.Threading.CancellationToken cancellationToken) { } + public static System.IObservable FromAsync(System.Func actionAsync) { } + public static System.IObservable FromAsync(System.Func actionAsync) { } + public static System.IObservable FromAsync(System.Func actionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable FromAsync(System.Func actionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.IObservable FromAsync(System.Func actionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable FromAsync(System.Func actionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.IObservable FromAsync(System.Func> functionAsync) { } + public static System.IObservable FromAsync(System.Func> functionAsync) { } + public static System.IObservable FromAsync(System.Func> functionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable FromAsync(System.Func> functionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.IObservable FromAsync(System.Func> functionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable FromAsync(System.Func> functionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Action end) { } + [System.Obsolete(@"This conversion is no longer supported. Replace use of the Begin/End asynchronous method pair with a new Task-based async method, and convert the result using ToObservable. If no Task-based async method is available, use Task.Factory.FromAsync to obtain a Task object.")] + public static System.Func> FromAsyncPattern(System.Func begin, System.Func end) { } + public static System.IObservable FromEvent(System.Action addHandler, System.Action removeHandler) { } + public static System.IObservable FromEvent(System.Action addHandler, System.Action removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable FromEvent(System.Action> addHandler, System.Action> removeHandler) { } + public static System.IObservable FromEvent(System.Action> addHandler, System.Action> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable FromEvent(System.Action addHandler, System.Action removeHandler) { } + public static System.IObservable FromEvent(System.Action addHandler, System.Action removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable FromEvent(System.Func, TDelegate> conversion, System.Action addHandler, System.Action removeHandler) { } + public static System.IObservable FromEvent(System.Func, TDelegate> conversion, System.Action addHandler, System.Action removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(System.Action addHandler, System.Action removeHandler) { } + public static System.IObservable> FromEventPattern(object target, string eventName) { } + public static System.IObservable> FromEventPattern(System.Type type, string eventName) { } + public static System.IObservable> FromEventPattern(System.Action addHandler, System.Action removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(object target, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(System.Type type, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(System.Action> addHandler, System.Action> removeHandler) { } + public static System.IObservable> FromEventPattern(object target, string eventName) { } + public static System.IObservable> FromEventPattern(System.Type type, string eventName) { } + public static System.IObservable> FromEventPattern(System.Action> addHandler, System.Action> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(object target, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(System.Type type, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(System.Action addHandler, System.Action removeHandler) { } + public static System.IObservable> FromEventPattern(object target, string eventName) { } + public static System.IObservable> FromEventPattern(System.Type type, string eventName) { } + public static System.IObservable> FromEventPattern(System.Action addHandler, System.Action removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(System.Func, TDelegate> conversion, System.Action addHandler, System.Action removeHandler) { } + public static System.IObservable> FromEventPattern(object target, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(System.Type type, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(System.Func, TDelegate> conversion, System.Action addHandler, System.Action removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> FromEventPattern(System.Action addHandler, System.Action removeHandler) { } + public static System.IObservable> FromEventPattern(System.Action addHandler, System.Action removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Generate(TState initialState, System.Func condition, System.Func iterate, System.Func resultSelector) { } + public static System.IObservable Generate(TState initialState, System.Func condition, System.Func iterate, System.Func resultSelector, System.Func timeSelector) { } + public static System.IObservable Generate(TState initialState, System.Func condition, System.Func iterate, System.Func resultSelector, System.Func timeSelector) { } + public static System.IObservable Generate(TState initialState, System.Func condition, System.Func iterate, System.Func resultSelector, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Generate(TState initialState, System.Func condition, System.Func iterate, System.Func resultSelector, System.Func timeSelector, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Generate(TState initialState, System.Func condition, System.Func iterate, System.Func resultSelector, System.Func timeSelector, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Subjects.AsyncSubject GetAwaiter(this System.IObservable source) { } + public static System.Reactive.Subjects.AsyncSubject GetAwaiter(this System.Reactive.Subjects.IConnectableObservable source) { } + public static System.Collections.Generic.IEnumerator GetEnumerator(this System.IObservable source) { } + public static System.IObservable> GroupBy(this System.IObservable source, System.Func keySelector) { } + public static System.IObservable> GroupBy(this System.IObservable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable> GroupBy(this System.IObservable source, System.Func keySelector, int capacity) { } + public static System.IObservable> GroupBy(this System.IObservable source, System.Func keySelector, int capacity, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable> GroupBy(this System.IObservable source, System.Func keySelector, System.Func elementSelector) { } + public static System.IObservable> GroupBy(this System.IObservable source, System.Func keySelector, System.Func elementSelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable> GroupBy(this System.IObservable source, System.Func keySelector, System.Func elementSelector, int capacity) { } + public static System.IObservable> GroupBy(this System.IObservable source, System.Func keySelector, System.Func elementSelector, int capacity, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable> GroupByUntil(this System.IObservable source, System.Func keySelector, System.Func, System.IObservable> durationSelector) { } + public static System.IObservable> GroupByUntil(this System.IObservable source, System.Func keySelector, System.Func, System.IObservable> durationSelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable> GroupByUntil(this System.IObservable source, System.Func keySelector, System.Func, System.IObservable> durationSelector, int capacity) { } + public static System.IObservable> GroupByUntil(this System.IObservable source, System.Func keySelector, System.Func, System.IObservable> durationSelector, int capacity, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable> GroupByUntil(this System.IObservable source, System.Func keySelector, System.Func elementSelector, System.Func, System.IObservable> durationSelector) { } + public static System.IObservable> GroupByUntil(this System.IObservable source, System.Func keySelector, System.Func elementSelector, System.Func, System.IObservable> durationSelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable> GroupByUntil(this System.IObservable source, System.Func keySelector, System.Func elementSelector, System.Func, System.IObservable> durationSelector, int capacity) { } + public static System.IObservable> GroupByUntil(this System.IObservable source, System.Func keySelector, System.Func elementSelector, System.Func, System.IObservable> durationSelector, int capacity, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable GroupJoin(this System.IObservable left, System.IObservable right, System.Func> leftDurationSelector, System.Func> rightDurationSelector, System.Func, TResult> resultSelector) { } + public static System.IObservable If(System.Func condition, System.IObservable thenSource) { } + public static System.IObservable If(System.Func condition, System.IObservable thenSource, System.IObservable elseSource) { } + public static System.IObservable If(System.Func condition, System.IObservable thenSource, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable IgnoreElements(this System.IObservable source) { } + public static System.IObservable Interval(System.TimeSpan period) { } + public static System.IObservable Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable IsEmpty(this System.IObservable source) { } + public static System.IObservable Join(this System.IObservable left, System.IObservable right, System.Func> leftDurationSelector, System.Func> rightDurationSelector, System.Func resultSelector) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + public static TSource Last(this System.IObservable source) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + public static TSource Last(this System.IObservable source, System.Func predicate) { } + public static System.IObservable LastAsync(this System.IObservable source) { } + public static System.IObservable LastAsync(this System.IObservable source, System.Func predicate) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + [return: System.Diagnostics.CodeAnalysis.MaybeNull] + public static TSource LastOrDefault(this System.IObservable source) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + [return: System.Diagnostics.CodeAnalysis.MaybeNull] + public static TSource LastOrDefault(this System.IObservable source, System.Func predicate) { } + public static System.IObservable LastOrDefaultAsync(this System.IObservable source) { } + public static System.IObservable LastOrDefaultAsync(this System.IObservable source, System.Func predicate) { } + public static System.Collections.Generic.IEnumerable Latest(this System.IObservable source) { } + public static System.IObservable LongCount(this System.IObservable source) { } + public static System.IObservable LongCount(this System.IObservable source, System.Func predicate) { } + public static System.IObservable> Materialize(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source) { } + public static System.IObservable Max(this System.IObservable source, System.Collections.Generic.IComparer comparer) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector) { } + public static System.IObservable Max(this System.IObservable source, System.Func selector, System.Collections.Generic.IComparer comparer) { } + public static System.IObservable> MaxBy(this System.IObservable source, System.Func keySelector) { } + public static System.IObservable> MaxBy(this System.IObservable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.IObservable Merge(params System.IObservable[] sources) { } + public static System.IObservable Merge(this System.Collections.Generic.IEnumerable> sources) { } + public static System.IObservable Merge(this System.IObservable> sources) { } + public static System.IObservable Merge(this System.IObservable> sources) { } + public static System.IObservable Merge(System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable[] sources) { } + public static System.IObservable Merge(this System.Collections.Generic.IEnumerable> sources, int maxConcurrent) { } + public static System.IObservable Merge(this System.Collections.Generic.IEnumerable> sources, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Merge(this System.IObservable> sources, int maxConcurrent) { } + public static System.IObservable Merge(this System.IObservable first, System.IObservable second) { } + public static System.IObservable Merge(this System.Collections.Generic.IEnumerable> sources, int maxConcurrent, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Merge(this System.IObservable first, System.IObservable second, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source) { } + public static System.IObservable Min(this System.IObservable source, System.Collections.Generic.IComparer comparer) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector) { } + public static System.IObservable Min(this System.IObservable source, System.Func selector, System.Collections.Generic.IComparer comparer) { } + public static System.IObservable> MinBy(this System.IObservable source, System.Func keySelector) { } + public static System.IObservable> MinBy(this System.IObservable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IEnumerable MostRecent(this System.IObservable source, TSource initialValue) { } + public static System.Reactive.Subjects.IConnectableObservable Multicast(this System.IObservable source, System.Reactive.Subjects.ISubject subject) { } + public static System.IObservable Multicast(this System.IObservable source, System.Func> subjectSelector, System.Func, System.IObservable> selector) { } + public static System.IObservable Never() { } + public static System.IObservable Never(TResult witness) { } + public static System.Collections.Generic.IEnumerable Next(this System.IObservable source) { } + public static System.IObservable ObserveOn(this System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable ObserveOn(this System.IObservable source, System.Threading.SynchronizationContext context) { } + public static System.IObservable OfType(this System.IObservable source) { } + public static System.IObservable OnErrorResumeNext(params System.IObservable[] sources) { } + public static System.IObservable OnErrorResumeNext(this System.Collections.Generic.IEnumerable> sources) { } + public static System.IObservable OnErrorResumeNext(this System.IObservable first, System.IObservable second) { } + public static System.IObservable Prepend(this System.IObservable source, TSource value) { } + public static System.IObservable Prepend(this System.IObservable source, TSource value, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Subjects.IConnectableObservable Publish(this System.IObservable source) { } + public static System.Reactive.Subjects.IConnectableObservable Publish(this System.IObservable source, TSource initialValue) { } + public static System.IObservable Publish(this System.IObservable source, System.Func, System.IObservable> selector) { } + public static System.IObservable Publish(this System.IObservable source, System.Func, System.IObservable> selector, TSource initialValue) { } + public static System.Reactive.Subjects.IConnectableObservable PublishLast(this System.IObservable source) { } + public static System.IObservable PublishLast(this System.IObservable source, System.Func, System.IObservable> selector) { } + public static System.IObservable Range(int start, int count) { } + public static System.IObservable Range(int start, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable RefCount(this System.Reactive.Subjects.IConnectableObservable source) { } + public static System.IObservable RefCount(this System.Reactive.Subjects.IConnectableObservable source, int minObservers) { } + public static System.IObservable RefCount(this System.Reactive.Subjects.IConnectableObservable source, System.TimeSpan disconnectDelay) { } + public static System.IObservable RefCount(this System.Reactive.Subjects.IConnectableObservable source, int minObservers, System.TimeSpan disconnectDelay) { } + public static System.IObservable RefCount(this System.Reactive.Subjects.IConnectableObservable source, System.TimeSpan disconnectDelay, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable RefCount(this System.Reactive.Subjects.IConnectableObservable source, int minObservers, System.TimeSpan disconnectDelay, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Repeat(TResult value) { } + public static System.IObservable Repeat(this System.IObservable source) { } + public static System.IObservable Repeat(TResult value, int repeatCount) { } + public static System.IObservable Repeat(TResult value, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Repeat(this System.IObservable source, int repeatCount) { } + public static System.IObservable Repeat(TResult value, int repeatCount, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable RepeatWhen(this System.IObservable source, System.Func, System.IObservable> handler) { } + public static System.Reactive.Subjects.IConnectableObservable Replay(this System.IObservable source) { } + public static System.Reactive.Subjects.IConnectableObservable Replay(this System.IObservable source, int bufferSize) { } + public static System.Reactive.Subjects.IConnectableObservable Replay(this System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Subjects.IConnectableObservable Replay(this System.IObservable source, System.TimeSpan window) { } + public static System.Reactive.Subjects.IConnectableObservable Replay(this System.IObservable source, int bufferSize, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Subjects.IConnectableObservable Replay(this System.IObservable source, int bufferSize, System.TimeSpan window) { } + public static System.Reactive.Subjects.IConnectableObservable Replay(this System.IObservable source, System.TimeSpan window, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Subjects.IConnectableObservable Replay(this System.IObservable source, int bufferSize, System.TimeSpan window, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Replay(this System.IObservable source, System.Func, System.IObservable> selector) { } + public static System.IObservable Replay(this System.IObservable source, System.Func, System.IObservable> selector, int bufferSize) { } + public static System.IObservable Replay(this System.IObservable source, System.Func, System.IObservable> selector, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Replay(this System.IObservable source, System.Func, System.IObservable> selector, System.TimeSpan window) { } + public static System.IObservable Replay(this System.IObservable source, System.Func, System.IObservable> selector, int bufferSize, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Replay(this System.IObservable source, System.Func, System.IObservable> selector, int bufferSize, System.TimeSpan window) { } + public static System.IObservable Replay(this System.IObservable source, System.Func, System.IObservable> selector, System.TimeSpan window, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Replay(this System.IObservable source, System.Func, System.IObservable> selector, int bufferSize, System.TimeSpan window, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Retry(this System.IObservable source) { } + public static System.IObservable Retry(this System.IObservable source, int retryCount) { } + public static System.IObservable RetryWhen(this System.IObservable source, System.Func, System.IObservable> handler) { } + public static System.IObservable Return(TResult value) { } + public static System.IObservable Return(TResult value, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Subjects.AsyncSubject RunAsync(this System.IObservable source, System.Threading.CancellationToken cancellationToken) { } + public static System.Reactive.Subjects.AsyncSubject RunAsync(this System.Reactive.Subjects.IConnectableObservable source, System.Threading.CancellationToken cancellationToken) { } + public static System.IObservable Sample(this System.IObservable source, System.TimeSpan interval) { } + public static System.IObservable Sample(this System.IObservable source, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Sample(this System.IObservable source, System.IObservable sampler) { } + public static System.IObservable Scan(this System.IObservable source, System.Func accumulator) { } + public static System.IObservable Scan(this System.IObservable source, TAccumulate seed, System.Func accumulator) { } + public static System.IObservable Select(this System.IObservable source, System.Func selector) { } + public static System.IObservable Select(this System.IObservable source, System.Func selector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> selector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> selector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> selector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> selector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> selector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> selector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> selector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> selector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.IObservable other) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> onNext, System.Func> onError, System.Func> onCompleted) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> onNext, System.Func> onError, System.Func> onCompleted) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> collectionSelector, System.Func resultSelector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> collectionSelector, System.Func resultSelector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> taskSelector, System.Func resultSelector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> collectionSelector, System.Func resultSelector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> collectionSelector, System.Func resultSelector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> taskSelector, System.Func resultSelector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> taskSelector, System.Func resultSelector) { } + public static System.IObservable SelectMany(this System.IObservable source, System.Func> taskSelector, System.Func resultSelector) { } + public static System.IObservable SequenceEqual(this System.IObservable first, System.Collections.Generic.IEnumerable second) { } + public static System.IObservable SequenceEqual(this System.IObservable first, System.IObservable second) { } + public static System.IObservable SequenceEqual(this System.IObservable first, System.Collections.Generic.IEnumerable second, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable SequenceEqual(this System.IObservable first, System.IObservable second, System.Collections.Generic.IEqualityComparer comparer) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + public static TSource Single(this System.IObservable source) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + public static TSource Single(this System.IObservable source, System.Func predicate) { } + public static System.IObservable SingleAsync(this System.IObservable source) { } + public static System.IObservable SingleAsync(this System.IObservable source, System.Func predicate) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + [return: System.Diagnostics.CodeAnalysis.MaybeNull] + public static TSource SingleOrDefault(this System.IObservable source) { } + [System.Obsolete(@"This blocking operation is no longer supported. Instead, use the async version in combination with C# and Visual Basic async/await support. In case you need a blocking operation, use Wait or convert the resulting observable sequence to a Task object and block.")] + [return: System.Diagnostics.CodeAnalysis.MaybeNull] + public static TSource SingleOrDefault(this System.IObservable source, System.Func predicate) { } + public static System.IObservable SingleOrDefaultAsync(this System.IObservable source) { } + public static System.IObservable SingleOrDefaultAsync(this System.IObservable source, System.Func predicate) { } + public static System.IObservable Skip(this System.IObservable source, int count) { } + public static System.IObservable Skip(this System.IObservable source, System.TimeSpan duration) { } + public static System.IObservable Skip(this System.IObservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable SkipLast(this System.IObservable source, int count) { } + public static System.IObservable SkipLast(this System.IObservable source, System.TimeSpan duration) { } + public static System.IObservable SkipLast(this System.IObservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable SkipUntil(this System.IObservable source, System.DateTimeOffset startTime) { } + public static System.IObservable SkipUntil(this System.IObservable source, System.DateTimeOffset startTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable SkipUntil(this System.IObservable source, System.IObservable other) { } + public static System.IObservable SkipWhile(this System.IObservable source, System.Func predicate) { } + public static System.IObservable SkipWhile(this System.IObservable source, System.Func predicate) { } + public static System.IObservable Start(System.Action action) { } + public static System.IObservable Start(System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Start(System.Func function) { } + public static System.IObservable Start(System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable StartAsync(System.Func actionAsync) { } + public static System.IObservable StartAsync(System.Func actionAsync) { } + public static System.IObservable StartAsync(System.Func actionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable StartAsync(System.Func actionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.IObservable StartAsync(System.Func actionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable StartAsync(System.Func actionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.IObservable StartAsync(System.Func> functionAsync) { } + public static System.IObservable StartAsync(System.Func> functionAsync) { } + public static System.IObservable StartAsync(System.Func> functionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable StartAsync(System.Func> functionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.IObservable StartAsync(System.Func> functionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable StartAsync(System.Func> functionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.IObservable StartWith(this System.IObservable source, System.Collections.Generic.IEnumerable values) { } + public static System.IObservable StartWith(this System.IObservable source, params TSource[] values) { } + public static System.IObservable StartWith(this System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler, System.Collections.Generic.IEnumerable values) { } + public static System.IObservable StartWith(this System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler, params TSource[] values) { } + public static System.IDisposable Subscribe(this System.Collections.Generic.IEnumerable source, System.IObserver observer) { } + public static System.IDisposable Subscribe(this System.Collections.Generic.IEnumerable source, System.IObserver observer, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable SubscribeOn(this System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable SubscribeOn(this System.IObservable source, System.Threading.SynchronizationContext context) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Sum(this System.IObservable source, System.Func selector) { } + public static System.IObservable Switch(this System.IObservable> sources) { } + public static System.IObservable Switch(this System.IObservable> sources) { } + public static System.IObservable Synchronize(this System.IObservable source) { } + public static System.IObservable Synchronize(this System.IObservable source, object gate) { } + public static System.IObservable Take(this System.IObservable source, int count) { } + public static System.IObservable Take(this System.IObservable source, System.TimeSpan duration) { } + public static System.IObservable Take(this System.IObservable source, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Take(this System.IObservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable TakeLast(this System.IObservable source, int count) { } + public static System.IObservable TakeLast(this System.IObservable source, System.TimeSpan duration) { } + public static System.IObservable TakeLast(this System.IObservable source, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable TakeLast(this System.IObservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable TakeLast(this System.IObservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler timerScheduler, System.Reactive.Concurrency.IScheduler loopScheduler) { } + public static System.IObservable> TakeLastBuffer(this System.IObservable source, int count) { } + public static System.IObservable> TakeLastBuffer(this System.IObservable source, System.TimeSpan duration) { } + public static System.IObservable> TakeLastBuffer(this System.IObservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable TakeUntil(this System.IObservable source, System.DateTimeOffset endTime) { } + public static System.IObservable TakeUntil(this System.IObservable source, System.Func stopPredicate) { } + public static System.IObservable TakeUntil(this System.IObservable source, System.DateTimeOffset endTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable TakeUntil(this System.IObservable source, System.IObservable other) { } + public static System.IObservable TakeWhile(this System.IObservable source, System.Func predicate) { } + public static System.IObservable TakeWhile(this System.IObservable source, System.Func predicate) { } + public static System.Reactive.Joins.Plan Then(this System.IObservable source, System.Func selector) { } + public static System.IObservable Throttle(this System.IObservable source, System.TimeSpan dueTime) { } + public static System.IObservable Throttle(this System.IObservable source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Throttle(this System.IObservable source, System.Func> throttleDurationSelector) { } + public static System.IObservable Throw(System.Exception exception) { } + public static System.IObservable Throw(System.Exception exception, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Throw(System.Exception exception, TResult witness) { } + public static System.IObservable Throw(System.Exception exception, System.Reactive.Concurrency.IScheduler scheduler, TResult witness) { } + public static System.IObservable> TimeInterval(this System.IObservable source) { } + public static System.IObservable> TimeInterval(this System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Timeout(this System.IObservable source, System.DateTimeOffset dueTime) { } + public static System.IObservable Timeout(this System.IObservable source, System.TimeSpan dueTime) { } + public static System.IObservable Timeout(this System.IObservable source, System.DateTimeOffset dueTime, System.IObservable other) { } + public static System.IObservable Timeout(this System.IObservable source, System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Timeout(this System.IObservable source, System.TimeSpan dueTime, System.IObservable other) { } + public static System.IObservable Timeout(this System.IObservable source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Timeout(this System.IObservable source, System.DateTimeOffset dueTime, System.IObservable other, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Timeout(this System.IObservable source, System.TimeSpan dueTime, System.IObservable other, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Timeout(this System.IObservable source, System.Func> timeoutDurationSelector) { } + public static System.IObservable Timeout(this System.IObservable source, System.Func> timeoutDurationSelector, System.IObservable other) { } + public static System.IObservable Timeout(this System.IObservable source, System.IObservable firstTimeout, System.Func> timeoutDurationSelector) { } + public static System.IObservable Timeout(this System.IObservable source, System.IObservable firstTimeout, System.Func> timeoutDurationSelector, System.IObservable other) { } + public static System.IObservable Timer(System.DateTimeOffset dueTime) { } + public static System.IObservable Timer(System.TimeSpan dueTime) { } + public static System.IObservable Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Timer(System.DateTimeOffset dueTime, System.TimeSpan period) { } + public static System.IObservable Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Timer(System.TimeSpan dueTime, System.TimeSpan period) { } + public static System.IObservable Timer(System.DateTimeOffset dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> Timestamp(this System.IObservable source) { } + public static System.IObservable> Timestamp(this System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable ToArray(this System.IObservable source) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Action action) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Action action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Func function) { } + public static System.Func> ToAsync(this System.Func function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> ToDictionary(this System.IObservable source, System.Func keySelector) + where TKey : notnull { } + public static System.IObservable> ToDictionary(this System.IObservable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer comparer) + where TKey : notnull { } + public static System.IObservable> ToDictionary(this System.IObservable source, System.Func keySelector, System.Func elementSelector) + where TKey : notnull { } + public static System.IObservable> ToDictionary(this System.IObservable source, System.Func keySelector, System.Func elementSelector, System.Collections.Generic.IEqualityComparer comparer) + where TKey : notnull { } + public static System.Collections.Generic.IEnumerable ToEnumerable(this System.IObservable source) { } + public static System.Reactive.IEventSource ToEvent(this System.IObservable source) { } + public static System.Reactive.IEventSource ToEvent(this System.IObservable source) { } + public static System.Reactive.IEventPatternSource ToEventPattern(this System.IObservable> source) { } + public static System.IObservable> ToList(this System.IObservable source) { } + public static System.IObservable> ToLookup(this System.IObservable source, System.Func keySelector) { } + public static System.IObservable> ToLookup(this System.IObservable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable> ToLookup(this System.IObservable source, System.Func keySelector, System.Func elementSelector) { } + public static System.IObservable> ToLookup(this System.IObservable source, System.Func keySelector, System.Func elementSelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.IObservable ToObservable(this System.Collections.Generic.IEnumerable source) { } + public static System.IObservable ToObservable(this System.Collections.Generic.IEnumerable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable Using(System.Func resourceFactory, System.Func> observableFactory) + where TResource : System.IDisposable { } + public static System.IObservable Using(System.Func> resourceFactoryAsync, System.Func>> observableFactoryAsync) + where TResource : System.IDisposable { } + public static TSource Wait(this System.IObservable source) { } + public static System.IObservable When(params System.Reactive.Joins.Plan[] plans) { } + public static System.IObservable When(this System.Collections.Generic.IEnumerable> plans) { } + public static System.IObservable Where(this System.IObservable source, System.Func predicate) { } + public static System.IObservable Where(this System.IObservable source, System.Func predicate) { } + public static System.IObservable While(System.Func condition, System.IObservable source) { } + public static System.IObservable> Window(this System.IObservable source, int count) { } + public static System.IObservable> Window(this System.IObservable source, System.TimeSpan timeSpan) { } + public static System.IObservable> Window(this System.IObservable source, int count, int skip) { } + public static System.IObservable> Window(this System.IObservable source, System.TimeSpan timeSpan, int count) { } + public static System.IObservable> Window(this System.IObservable source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> Window(this System.IObservable source, System.TimeSpan timeSpan, System.TimeSpan timeShift) { } + public static System.IObservable> Window(this System.IObservable source, System.TimeSpan timeSpan, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> Window(this System.IObservable source, System.TimeSpan timeSpan, System.TimeSpan timeShift, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable> Window(this System.IObservable source, System.Func> windowClosingSelector) { } + public static System.IObservable> Window(this System.IObservable source, System.IObservable windowBoundaries) { } + public static System.IObservable> Window(this System.IObservable source, System.IObservable windowOpenings, System.Func> windowClosingSelector) { } + public static System.IObservable WithLatestFrom(this System.IObservable first, System.IObservable second, System.Func resultSelector) { } + public static System.IObservable> Zip(params System.IObservable[] sources) { } + public static System.IObservable> Zip(this System.Collections.Generic.IEnumerable> sources) { } + public static System.IObservable Zip(this System.Collections.Generic.IEnumerable> sources, System.Func, TResult> resultSelector) { } + public static System.IObservable Zip(this System.IObservable first, System.Collections.Generic.IEnumerable second, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable first, System.IObservable second, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.IObservable source13, System.Func resultSelector) { } + public static System.IObservable Zip(this System.IObservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.IObservable source13, System.IObservable source14, System.Func resultSelector) { } + public static System.IObservable Zip( + this System.IObservable source1, + System.IObservable source2, + System.IObservable source3, + System.IObservable source4, + System.IObservable source5, + System.IObservable source6, + System.IObservable source7, + System.IObservable source8, + System.IObservable source9, + System.IObservable source10, + System.IObservable source11, + System.IObservable source12, + System.IObservable source13, + System.IObservable source14, + System.IObservable source15, + System.Func resultSelector) { } + public static System.IObservable Zip( + this System.IObservable source1, + System.IObservable source2, + System.IObservable source3, + System.IObservable source4, + System.IObservable source5, + System.IObservable source6, + System.IObservable source7, + System.IObservable source8, + System.IObservable source9, + System.IObservable source10, + System.IObservable source11, + System.IObservable source12, + System.IObservable source13, + System.IObservable source14, + System.IObservable source15, + System.IObservable source16, + System.Func resultSelector) { } + } + public static class ObservableEx + { + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second"})] + public static System.IObservable> CombineLatest(this System.IObservable first, System.IObservable second) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third"})] + public static System.IObservable> CombineLatest(this System.IObservable first, System.IObservable second, System.IObservable third) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth"})] + public static System.IObservable> CombineLatest(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth"})] + public static System.IObservable> CombineLatest(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth"})] + public static System.IObservable> CombineLatest(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh"})] + public static System.IObservable> CombineLatest(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + null})] + public static System.IObservable>> CombineLatest(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth) { } + [System.Reactive.Experimental] + public static System.IObservable Create(System.Func>> iteratorMethod) { } + [System.Reactive.Experimental] + public static System.IObservable Create(System.Func, System.Collections.Generic.IEnumerable>> iteratorMethod) { } + [System.Reactive.Experimental] + public static System.IObservable Expand(this System.IObservable source, System.Func> selector) { } + [System.Reactive.Experimental] + public static System.IObservable Expand(this System.IObservable source, System.Func> selector, System.Reactive.Concurrency.IScheduler scheduler) { } + [System.Reactive.Experimental] + public static System.IObservable ForkJoin(params System.IObservable[] sources) { } + [System.Reactive.Experimental] + public static System.IObservable ForkJoin(this System.Collections.Generic.IEnumerable> sources) { } + [System.Reactive.Experimental] + public static System.IObservable ForkJoin(this System.IObservable first, System.IObservable second, System.Func resultSelector) { } + [System.Reactive.Experimental] + public static System.IObservable Let(this System.IObservable source, System.Func, System.IObservable> selector) { } + [System.Reactive.Experimental] + public static System.IObservable ManySelect(this System.IObservable source, System.Func, TResult> selector) { } + [System.Reactive.Experimental] + public static System.IObservable ManySelect(this System.IObservable source, System.Func, TResult> selector, System.Reactive.Concurrency.IScheduler scheduler) { } + [System.Reactive.Experimental] + public static System.Reactive.ListObservable ToListObservable(this System.IObservable source) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second"})] + public static System.IObservable> WithLatestFrom(this System.IObservable first, System.IObservable second) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second"})] + public static System.IObservable> Zip(this System.IObservable first, System.Collections.Generic.IEnumerable second) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second"})] + public static System.IObservable> Zip(this System.IObservable first, System.IObservable second) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third"})] + public static System.IObservable> Zip(this System.IObservable first, System.IObservable second, System.IObservable third) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth"})] + public static System.IObservable> Zip(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth"})] + public static System.IObservable> Zip(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth"})] + public static System.IObservable> Zip(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh"})] + public static System.IObservable> Zip(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + null})] + public static System.IObservable>> Zip(this System.IObservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth) { } + } + [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] + public static class Qbservable + { + public static System.Reactive.Linq.IQbservableProvider Provider { get; } + public static System.Reactive.Linq.IQbservable Aggregate(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> accumulator) { } + public static System.Reactive.Linq.IQbservable Aggregate(this System.Reactive.Linq.IQbservable source, TAccumulate seed, System.Linq.Expressions.Expression> accumulator) { } + public static System.Reactive.Linq.IQbservable Aggregate(this System.Reactive.Linq.IQbservable source, TAccumulate seed, System.Linq.Expressions.Expression> accumulator, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable All(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable Amb(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } + public static System.Reactive.Linq.IQbservable Amb(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } + public static System.Reactive.Linq.IQbservable Amb(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } + public static System.Reactive.Joins.QueryablePattern And(this System.Reactive.Linq.IQbservable left, System.IObservable right) { } + public static System.Reactive.Linq.IQbservable Any(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Any(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable Append(this System.Reactive.Linq.IQbservable source, TSource value) { } + public static System.Reactive.Linq.IQbservable Append(this System.Reactive.Linq.IQbservable source, TSource value, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable AsObservable(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable AsQbservable(this System.IObservable source) { } + public static System.Reactive.Linq.IQbservable AutoConnect(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Subjects.IConnectableObservable source, int minObservers, System.Linq.Expressions.Expression> onConnect) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Average(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, int count) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, int count, int skip) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, int count) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, System.TimeSpan timeShift) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, System.TimeSpan timeShift, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, System.IObservable bufferBoundaries) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> bufferClosingSelector) { } + public static System.Reactive.Linq.IQbservable> Buffer(this System.Reactive.Linq.IQbservable source, System.IObservable bufferOpenings, System.Linq.Expressions.Expression>> bufferClosingSelector) { } + public static System.Reactive.Linq.IQbservable Case(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> selector, System.Collections.Generic.IDictionary> sources) + where TValue : notnull { } + public static System.Reactive.Linq.IQbservable Case(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> selector, System.Collections.Generic.IDictionary> sources, System.IObservable defaultSource) + where TValue : notnull { } + public static System.Reactive.Linq.IQbservable Case(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> selector, System.Collections.Generic.IDictionary> sources, System.Reactive.Concurrency.IScheduler scheduler) + where TValue : notnull { } + public static System.Reactive.Linq.IQbservable Cast(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Catch(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } + public static System.Reactive.Linq.IQbservable Catch(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } + public static System.Reactive.Linq.IQbservable Catch(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } + public static System.Reactive.Linq.IQbservable Catch(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> handler) + where TException : System.Exception { } + public static System.Linq.IQueryable> Chunkify(this System.Reactive.Linq.IQbservable source) { } + public static System.Linq.IQueryable Collect(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> newCollector, System.Linq.Expressions.Expression> merge) { } + public static System.Linq.IQueryable Collect(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> getInitialCollector, System.Linq.Expressions.Expression> merge, System.Linq.Expressions.Expression> getNewCollector) { } + public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } + public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, System.Linq.Expressions.Expression, TResult>> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.IObservable source13, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.IObservable source13, System.IObservable source14, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest( + this System.Reactive.Linq.IQbservable source1, + System.IObservable source2, + System.IObservable source3, + System.IObservable source4, + System.IObservable source5, + System.IObservable source6, + System.IObservable source7, + System.IObservable source8, + System.IObservable source9, + System.IObservable source10, + System.IObservable source11, + System.IObservable source12, + System.IObservable source13, + System.IObservable source14, + System.IObservable source15, + System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable CombineLatest( + this System.Reactive.Linq.IQbservable source1, + System.IObservable source2, + System.IObservable source3, + System.IObservable source4, + System.IObservable source5, + System.IObservable source6, + System.IObservable source7, + System.IObservable source8, + System.IObservable source9, + System.IObservable source10, + System.IObservable source11, + System.IObservable source12, + System.IObservable source13, + System.IObservable source14, + System.IObservable source15, + System.IObservable source16, + System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservable> sources) { } + public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservable> sources) { } + public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } + public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } + public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } + public static System.Reactive.Linq.IQbservable Contains(this System.Reactive.Linq.IQbservable source, TSource value) { } + public static System.Reactive.Linq.IQbservable Contains(this System.Reactive.Linq.IQbservable source, TSource value, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable Count(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Count(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, System.Action>> subscribe) { } + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, System.IDisposable>> subscribe) { } + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, System.Threading.Tasks.Task>> subscribeAsync) { } + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, System.Threading.Tasks.Task>> subscribeAsync) { } + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, System.Threading.Tasks.Task>> subscribeAsync) { } + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, System.Threading.CancellationToken, System.Threading.Tasks.Task>> subscribeAsync) { } + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, System.Threading.CancellationToken, System.Threading.Tasks.Task>> subscribeAsync) { } + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, System.Threading.CancellationToken, System.Threading.Tasks.Task>> subscribeAsync) { } + public static System.Reactive.Linq.IQbservable DefaultIfEmpty(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable DefaultIfEmpty(this System.Reactive.Linq.IQbservable source, TSource defaultValue) { } + public static System.Reactive.Linq.IQbservable Defer(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> observableFactory) { } + public static System.Reactive.Linq.IQbservable Defer(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>>> observableFactoryAsync) { } + public static System.Reactive.Linq.IQbservable Defer(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe) { } + public static System.Reactive.Linq.IQbservable DeferAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>>> observableFactoryAsync) { } + public static System.Reactive.Linq.IQbservable DeferAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe) { } + public static System.Reactive.Linq.IQbservable Delay(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset dueTime) { } + public static System.Reactive.Linq.IQbservable Delay(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime) { } + public static System.Reactive.Linq.IQbservable Delay(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Delay(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Delay(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> delayDurationSelector) { } + public static System.Reactive.Linq.IQbservable Delay(this System.Reactive.Linq.IQbservable source, System.IObservable subscriptionDelay, System.Linq.Expressions.Expression>> delayDurationSelector) { } + public static System.Reactive.Linq.IQbservable DelaySubscription(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset dueTime) { } + public static System.Reactive.Linq.IQbservable DelaySubscription(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime) { } + public static System.Reactive.Linq.IQbservable DelaySubscription(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable DelaySubscription(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Dematerialize(this System.Reactive.Linq.IQbservable> source) { } + public static System.Reactive.Linq.IQbservable Distinct(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Distinct(this System.Reactive.Linq.IQbservable source, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable Distinct(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Reactive.Linq.IQbservable Distinct(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable DistinctUntilChanged(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable DistinctUntilChanged(this System.Reactive.Linq.IQbservable source, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable DistinctUntilChanged(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Reactive.Linq.IQbservable DistinctUntilChanged(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable Do(this System.Reactive.Linq.IQbservable source, System.IObserver observer) { } + public static System.Reactive.Linq.IQbservable Do(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> onNext) { } + public static System.Reactive.Linq.IQbservable Do(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression onCompleted) { } + public static System.Reactive.Linq.IQbservable Do(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError) { } + public static System.Reactive.Linq.IQbservable Do(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError, System.Linq.Expressions.Expression onCompleted) { } + public static System.Reactive.Linq.IQbservable DoWhile(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> condition) { } + public static System.Reactive.Linq.IQbservable ElementAt(this System.Reactive.Linq.IQbservable source, int index) { } + public static System.Reactive.Linq.IQbservable ElementAtOrDefault(this System.Reactive.Linq.IQbservable source, int index) { } + public static System.Reactive.Linq.IQbservable Empty(this System.Reactive.Linq.IQbservableProvider provider) { } + public static System.Reactive.Linq.IQbservable Empty(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Empty(this System.Reactive.Linq.IQbservableProvider provider, TResult witness) { } + public static System.Reactive.Linq.IQbservable Empty(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Concurrency.IScheduler scheduler, TResult witness) { } + public static System.Reactive.Linq.IQbservable Finally(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression finallyAction) { } + public static System.Reactive.Linq.IQbservable FirstAsync(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable FirstAsync(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable FirstOrDefaultAsync(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable FirstOrDefaultAsync(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable For(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable source, System.Linq.Expressions.Expression>> resultSelector) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable FromAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Func> FromAsyncPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> begin, System.Linq.Expressions.Expression> end) { } + public static System.Reactive.Linq.IQbservable FromEvent(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler) { } + public static System.Reactive.Linq.IQbservable FromEvent(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable FromEvent(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> addHandler, System.Linq.Expressions.Expression>> removeHandler) { } + public static System.Reactive.Linq.IQbservable FromEvent(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> addHandler, System.Linq.Expressions.Expression>> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable FromEvent(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler) { } + public static System.Reactive.Linq.IQbservable FromEvent(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable FromEvent(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, TDelegate>> conversion, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler) { } + public static System.Reactive.Linq.IQbservable FromEvent(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, TDelegate>> conversion, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, object target, string eventName) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Type type, string eventName) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, object target, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Type type, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> addHandler, System.Linq.Expressions.Expression>> removeHandler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, object target, string eventName) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Type type, string eventName) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> addHandler, System.Linq.Expressions.Expression>> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, object target, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Type type, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, object target, string eventName) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Type type, string eventName) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, TDelegate>> conversion, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, object target, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Type type, string eventName, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, TDelegate>> conversion, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler) { } + public static System.Reactive.Linq.IQbservable> FromEventPattern(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> addHandler, System.Linq.Expressions.Expression> removeHandler, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Generate(this System.Reactive.Linq.IQbservableProvider provider, TState initialState, System.Linq.Expressions.Expression> condition, System.Linq.Expressions.Expression> iterate, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Generate(this System.Reactive.Linq.IQbservableProvider provider, TState initialState, System.Linq.Expressions.Expression> condition, System.Linq.Expressions.Expression> iterate, System.Linq.Expressions.Expression> resultSelector, System.Linq.Expressions.Expression> timeSelector) { } + public static System.Reactive.Linq.IQbservable Generate(this System.Reactive.Linq.IQbservableProvider provider, TState initialState, System.Linq.Expressions.Expression> condition, System.Linq.Expressions.Expression> iterate, System.Linq.Expressions.Expression> resultSelector, System.Linq.Expressions.Expression> timeSelector) { } + public static System.Reactive.Linq.IQbservable Generate(this System.Reactive.Linq.IQbservableProvider provider, TState initialState, System.Linq.Expressions.Expression> condition, System.Linq.Expressions.Expression> iterate, System.Linq.Expressions.Expression> resultSelector, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Generate(this System.Reactive.Linq.IQbservableProvider provider, TState initialState, System.Linq.Expressions.Expression> condition, System.Linq.Expressions.Expression> iterate, System.Linq.Expressions.Expression> resultSelector, System.Linq.Expressions.Expression> timeSelector, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Generate(this System.Reactive.Linq.IQbservableProvider provider, TState initialState, System.Linq.Expressions.Expression> condition, System.Linq.Expressions.Expression> iterate, System.Linq.Expressions.Expression> resultSelector, System.Linq.Expressions.Expression> timeSelector, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> GroupBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Reactive.Linq.IQbservable> GroupBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable> GroupBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, int capacity) { } + public static System.Reactive.Linq.IQbservable> GroupBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, int capacity, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable> GroupBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector) { } + public static System.Reactive.Linq.IQbservable> GroupBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable> GroupBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, int capacity) { } + public static System.Reactive.Linq.IQbservable> GroupBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, int capacity, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable> GroupByUntil(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression, System.IObservable>> durationSelector) { } + public static System.Reactive.Linq.IQbservable> GroupByUntil(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression, System.IObservable>> durationSelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable> GroupByUntil(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression, System.IObservable>> durationSelector, int capacity) { } + public static System.Reactive.Linq.IQbservable> GroupByUntil(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression, System.IObservable>> durationSelector, int capacity, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable> GroupByUntil(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Linq.Expressions.Expression, System.IObservable>> durationSelector) { } + public static System.Reactive.Linq.IQbservable> GroupByUntil(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Linq.Expressions.Expression, System.IObservable>> durationSelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable> GroupByUntil(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Linq.Expressions.Expression, System.IObservable>> durationSelector, int capacity) { } + public static System.Reactive.Linq.IQbservable> GroupByUntil(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Linq.Expressions.Expression, System.IObservable>> durationSelector, int capacity, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable GroupJoin(this System.Reactive.Linq.IQbservable left, System.IObservable right, System.Linq.Expressions.Expression>> leftDurationSelector, System.Linq.Expressions.Expression>> rightDurationSelector, System.Linq.Expressions.Expression, TResult>> resultSelector) { } + public static System.Reactive.Linq.IQbservable If(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> condition, System.IObservable thenSource) { } + public static System.Reactive.Linq.IQbservable If(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> condition, System.IObservable thenSource, System.IObservable elseSource) { } + public static System.Reactive.Linq.IQbservable If(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> condition, System.IObservable thenSource, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable IgnoreElements(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Interval(this System.Reactive.Linq.IQbservableProvider provider, System.TimeSpan period) { } + public static System.Reactive.Linq.IQbservable Interval(this System.Reactive.Linq.IQbservableProvider provider, System.TimeSpan period, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable IsEmpty(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Join(this System.Reactive.Linq.IQbservable left, System.IObservable right, System.Linq.Expressions.Expression>> leftDurationSelector, System.Linq.Expressions.Expression>> rightDurationSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable LastAsync(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable LastAsync(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable LastOrDefaultAsync(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable LastOrDefaultAsync(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Linq.IQueryable Latest(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable LongCount(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable LongCount(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable> Materialize(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Collections.Generic.IComparer comparer) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Max(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector, System.Collections.Generic.IComparer comparer) { } + public static System.Reactive.Linq.IQbservable> MaxBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Reactive.Linq.IQbservable> MaxBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable> sources) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable> sources) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable> sources, int maxConcurrent) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, int maxConcurrent) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable[] sources) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, int maxConcurrent, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Collections.Generic.IComparer comparer) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector, System.Collections.Generic.IComparer comparer) { } + public static System.Reactive.Linq.IQbservable> MinBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Reactive.Linq.IQbservable> MinBy(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IQueryable MostRecent(this System.Reactive.Linq.IQbservable source, TSource initialValue) { } + public static System.Reactive.Linq.IQbservable Multicast(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> subjectSelector, System.Linq.Expressions.Expression, System.IObservable>> selector) { } + public static System.Reactive.Linq.IQbservable Never(this System.Reactive.Linq.IQbservableProvider provider) { } + public static System.Reactive.Linq.IQbservable Never(this System.Reactive.Linq.IQbservableProvider provider, TResult witness) { } + public static System.Linq.IQueryable Next(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable ObserveOn(this System.Reactive.Linq.IQbservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable ObserveOn(this System.Reactive.Linq.IQbservable source, System.Threading.SynchronizationContext context) { } + public static System.Reactive.Linq.IQbservable OfType(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable OnErrorResumeNext(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } + public static System.Reactive.Linq.IQbservable OnErrorResumeNext(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } + public static System.Reactive.Linq.IQbservable OnErrorResumeNext(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } + public static System.Reactive.Linq.IQbservable Prepend(this System.Reactive.Linq.IQbservable source, TSource value) { } + public static System.Reactive.Linq.IQbservable Prepend(this System.Reactive.Linq.IQbservable source, TSource value, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Publish(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector) { } + public static System.Reactive.Linq.IQbservable Publish(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector, TSource initialValue) { } + public static System.Reactive.Linq.IQbservable PublishLast(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector) { } + public static System.Reactive.Linq.IQbservable Range(this System.Reactive.Linq.IQbservableProvider provider, int start, int count) { } + public static System.Reactive.Linq.IQbservable Range(this System.Reactive.Linq.IQbservableProvider provider, int start, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable RefCount(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Subjects.IConnectableObservable source) { } + public static System.Reactive.Linq.IQbservable RefCount(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Subjects.IConnectableObservable source, int minObservers) { } + public static System.Reactive.Linq.IQbservable RefCount(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Subjects.IConnectableObservable source, System.TimeSpan disconnectDelay) { } + public static System.Reactive.Linq.IQbservable RefCount(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Subjects.IConnectableObservable source, int minObservers, System.TimeSpan disconnectDelay) { } + public static System.Reactive.Linq.IQbservable RefCount(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Subjects.IConnectableObservable source, System.TimeSpan disconnectDelay, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable RefCount(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Subjects.IConnectableObservable source, int minObservers, System.TimeSpan disconnectDelay, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Repeat(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Repeat(this System.Reactive.Linq.IQbservableProvider provider, TResult value) { } + public static System.Reactive.Linq.IQbservable Repeat(this System.Reactive.Linq.IQbservable source, int repeatCount) { } + public static System.Reactive.Linq.IQbservable Repeat(this System.Reactive.Linq.IQbservableProvider provider, TResult value, int repeatCount) { } + public static System.Reactive.Linq.IQbservable Repeat(this System.Reactive.Linq.IQbservableProvider provider, TResult value, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Repeat(this System.Reactive.Linq.IQbservableProvider provider, TResult value, int repeatCount, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable RepeatWhen(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> handler) { } + public static System.Reactive.Linq.IQbservable Replay(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector) { } + public static System.Reactive.Linq.IQbservable Replay(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector, int bufferSize) { } + public static System.Reactive.Linq.IQbservable Replay(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Replay(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector, System.TimeSpan window) { } + public static System.Reactive.Linq.IQbservable Replay(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector, int bufferSize, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Replay(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector, int bufferSize, System.TimeSpan window) { } + public static System.Reactive.Linq.IQbservable Replay(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector, System.TimeSpan window, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Replay(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector, int bufferSize, System.TimeSpan window, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Retry(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Retry(this System.Reactive.Linq.IQbservable source, int retryCount) { } + public static System.Reactive.Linq.IQbservable RetryWhen(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> handler) { } + public static System.Reactive.Linq.IQbservable Return(this System.Reactive.Linq.IQbservableProvider provider, TResult value) { } + public static System.Reactive.Linq.IQbservable Return(this System.Reactive.Linq.IQbservableProvider provider, TResult value, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Sample(this System.Reactive.Linq.IQbservable source, System.TimeSpan interval) { } + public static System.Reactive.Linq.IQbservable Sample(this System.Reactive.Linq.IQbservable source, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Sample(this System.Reactive.Linq.IQbservable source, System.IObservable sampler) { } + public static System.Reactive.Linq.IQbservable Scan(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> accumulator) { } + public static System.Reactive.Linq.IQbservable Scan(this System.Reactive.Linq.IQbservable source, TAccumulate seed, System.Linq.Expressions.Expression> accumulator) { } + public static System.Reactive.Linq.IQbservable Select(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Select(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.IObservable other) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> onNext, System.Linq.Expressions.Expression>> onError, System.Linq.Expressions.Expression>> onCompleted) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> onNext, System.Linq.Expressions.Expression>> onError, System.Linq.Expressions.Expression>> onCompleted) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> collectionSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> collectionSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> taskSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> collectionSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> collectionSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> taskSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> taskSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable SelectMany(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> taskSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable SequenceEqual(this System.Reactive.Linq.IQbservable first, System.Collections.Generic.IEnumerable second) { } + public static System.Reactive.Linq.IQbservable SequenceEqual(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } + public static System.Reactive.Linq.IQbservable SequenceEqual(this System.Reactive.Linq.IQbservable first, System.Collections.Generic.IEnumerable second, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable SequenceEqual(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable SingleAsync(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable SingleAsync(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable SingleOrDefaultAsync(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable SingleOrDefaultAsync(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable Skip(this System.Reactive.Linq.IQbservable source, int count) { } + public static System.Reactive.Linq.IQbservable Skip(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration) { } + public static System.Reactive.Linq.IQbservable Skip(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable SkipLast(this System.Reactive.Linq.IQbservable source, int count) { } + public static System.Reactive.Linq.IQbservable SkipLast(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration) { } + public static System.Reactive.Linq.IQbservable SkipLast(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable SkipUntil(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset startTime) { } + public static System.Reactive.Linq.IQbservable SkipUntil(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset startTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable SkipUntil(this System.Reactive.Linq.IQbservable source, System.IObservable other) { } + public static System.Reactive.Linq.IQbservable SkipWhile(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable SkipWhile(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable Start(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression action) { } + public static System.Reactive.Linq.IQbservable Start(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Start(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Reactive.Linq.IQbservable Start(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> actionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable StartAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> functionAsync, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.Reactive.Linq.IQbservable StartWith(this System.Reactive.Linq.IQbservable source, System.Collections.Generic.IEnumerable values) { } + public static System.Reactive.Linq.IQbservable StartWith(this System.Reactive.Linq.IQbservable source, params TSource[] values) { } + public static System.Reactive.Linq.IQbservable StartWith(this System.Reactive.Linq.IQbservable source, System.Reactive.Concurrency.IScheduler scheduler, System.Collections.Generic.IEnumerable values) { } + public static System.Reactive.Linq.IQbservable StartWith(this System.Reactive.Linq.IQbservable source, System.Reactive.Concurrency.IScheduler scheduler, params TSource[] values) { } + public static System.Reactive.Linq.IQbservable SubscribeOn(this System.Reactive.Linq.IQbservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable SubscribeOn(this System.Reactive.Linq.IQbservable source, System.Threading.SynchronizationContext context) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Sum(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Switch(this System.Reactive.Linq.IQbservable> sources) { } + public static System.Reactive.Linq.IQbservable Switch(this System.Reactive.Linq.IQbservable> sources) { } + public static System.Reactive.Linq.IQbservable Synchronize(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Synchronize(this System.Reactive.Linq.IQbservable source, object gate) { } + public static System.Reactive.Linq.IQbservable Take(this System.Reactive.Linq.IQbservable source, int count) { } + public static System.Reactive.Linq.IQbservable Take(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration) { } + public static System.Reactive.Linq.IQbservable Take(this System.Reactive.Linq.IQbservable source, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Take(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable TakeLast(this System.Reactive.Linq.IQbservable source, int count) { } + public static System.Reactive.Linq.IQbservable TakeLast(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration) { } + public static System.Reactive.Linq.IQbservable TakeLast(this System.Reactive.Linq.IQbservable source, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable TakeLast(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable TakeLast(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler timerScheduler, System.Reactive.Concurrency.IScheduler loopScheduler) { } + public static System.Reactive.Linq.IQbservable> TakeLastBuffer(this System.Reactive.Linq.IQbservable source, int count) { } + public static System.Reactive.Linq.IQbservable> TakeLastBuffer(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration) { } + public static System.Reactive.Linq.IQbservable> TakeLastBuffer(this System.Reactive.Linq.IQbservable source, System.TimeSpan duration, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable TakeUntil(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset endTime) { } + public static System.Reactive.Linq.IQbservable TakeUntil(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> stopPredicate) { } + public static System.Reactive.Linq.IQbservable TakeUntil(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset endTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable TakeUntil(this System.Reactive.Linq.IQbservable source, System.IObservable other) { } + public static System.Reactive.Linq.IQbservable TakeWhile(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable TakeWhile(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Joins.QueryablePlan Then(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> selector) { } + public static System.Reactive.Linq.IQbservable Throttle(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime) { } + public static System.Reactive.Linq.IQbservable Throttle(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Throttle(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> throttleDurationSelector) { } + public static System.Reactive.Linq.IQbservable Throw(this System.Reactive.Linq.IQbservableProvider provider, System.Exception exception) { } + public static System.Reactive.Linq.IQbservable Throw(this System.Reactive.Linq.IQbservableProvider provider, System.Exception exception, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Throw(this System.Reactive.Linq.IQbservableProvider provider, System.Exception exception, TResult witness) { } + public static System.Reactive.Linq.IQbservable Throw(this System.Reactive.Linq.IQbservableProvider provider, System.Exception exception, System.Reactive.Concurrency.IScheduler scheduler, TResult witness) { } + public static System.Reactive.Linq.IQbservable> TimeInterval(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable> TimeInterval(this System.Reactive.Linq.IQbservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset dueTime) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset dueTime, System.IObservable other) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime, System.IObservable other) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.DateTimeOffset dueTime, System.IObservable other, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.TimeSpan dueTime, System.IObservable other, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> timeoutDurationSelector) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.IObservable firstTimeout, System.Linq.Expressions.Expression>> timeoutDurationSelector) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> timeoutDurationSelector, System.IObservable other) { } + public static System.Reactive.Linq.IQbservable Timeout(this System.Reactive.Linq.IQbservable source, System.IObservable firstTimeout, System.Linq.Expressions.Expression>> timeoutDurationSelector, System.IObservable other) { } + public static System.Reactive.Linq.IQbservable Timer(this System.Reactive.Linq.IQbservableProvider provider, System.DateTimeOffset dueTime) { } + public static System.Reactive.Linq.IQbservable Timer(this System.Reactive.Linq.IQbservableProvider provider, System.TimeSpan dueTime) { } + public static System.Reactive.Linq.IQbservable Timer(this System.Reactive.Linq.IQbservableProvider provider, System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Timer(this System.Reactive.Linq.IQbservableProvider provider, System.DateTimeOffset dueTime, System.TimeSpan period) { } + public static System.Reactive.Linq.IQbservable Timer(this System.Reactive.Linq.IQbservableProvider provider, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Timer(this System.Reactive.Linq.IQbservableProvider provider, System.TimeSpan dueTime, System.TimeSpan period) { } + public static System.Reactive.Linq.IQbservable Timer(this System.Reactive.Linq.IQbservableProvider provider, System.DateTimeOffset dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable Timer(this System.Reactive.Linq.IQbservableProvider provider, System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> Timestamp(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable> Timestamp(this System.Reactive.Linq.IQbservable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable ToArray(this System.Reactive.Linq.IQbservable source) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> action, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function) { } + public static System.Func> ToAsync(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> function, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> ToDictionary(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector) + where TKey : notnull { } + public static System.Reactive.Linq.IQbservable> ToDictionary(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer comparer) + where TKey : notnull { } + public static System.Reactive.Linq.IQbservable> ToDictionary(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector) + where TKey : notnull { } + public static System.Reactive.Linq.IQbservable> ToDictionary(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Collections.Generic.IEqualityComparer comparer) + where TKey : notnull { } + public static System.Reactive.Linq.IQbservable> ToList(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable> ToLookup(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Reactive.Linq.IQbservable> ToLookup(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable> ToLookup(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector) { } + public static System.Reactive.Linq.IQbservable> ToLookup(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Reactive.Linq.IQbservable ToObservable(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable source) { } + public static System.Reactive.Linq.IQbservable ToObservable(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable ToQbservable(this System.Linq.IQueryable source) { } + public static System.Reactive.Linq.IQbservable ToQbservable(this System.Linq.IQueryable source, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Linq.IQueryable ToQueryable(this System.Reactive.Linq.IQbservable source) { } + public static System.Reactive.Linq.IQbservable Using(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> resourceFactory, System.Linq.Expressions.Expression>> observableFactory) + where TResource : System.IDisposable { } + public static System.Reactive.Linq.IQbservable Using(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> resourceFactoryAsync, System.Linq.Expressions.Expression>>> observableFactoryAsync) + where TResource : System.IDisposable { } + public static System.Reactive.Linq.IQbservable When(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> plans) { } + public static System.Reactive.Linq.IQbservable When(this System.Reactive.Linq.IQbservableProvider provider, params System.Reactive.Joins.QueryablePlan[] plans) { } + public static System.Reactive.Linq.IQbservable Where(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable Where(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Reactive.Linq.IQbservable While(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> condition, System.IObservable source) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, int count) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, int count, int skip) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, int count) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, System.TimeSpan timeShift) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, int count, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.TimeSpan timeSpan, System.TimeSpan timeShift, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.IObservable windowBoundaries) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> windowClosingSelector) { } + public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.IObservable windowOpenings, System.Linq.Expressions.Expression>> windowClosingSelector) { } + public static System.Reactive.Linq.IQbservable WithLatestFrom(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, System.Linq.Expressions.Expression, TResult>> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable first, System.Collections.Generic.IEnumerable second, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.IObservable source13, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.IObservable source4, System.IObservable source5, System.IObservable source6, System.IObservable source7, System.IObservable source8, System.IObservable source9, System.IObservable source10, System.IObservable source11, System.IObservable source12, System.IObservable source13, System.IObservable source14, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip( + this System.Reactive.Linq.IQbservable source1, + System.IObservable source2, + System.IObservable source3, + System.IObservable source4, + System.IObservable source5, + System.IObservable source6, + System.IObservable source7, + System.IObservable source8, + System.IObservable source9, + System.IObservable source10, + System.IObservable source11, + System.IObservable source12, + System.IObservable source13, + System.IObservable source14, + System.IObservable source15, + System.Linq.Expressions.Expression> resultSelector) { } + public static System.Reactive.Linq.IQbservable Zip( + this System.Reactive.Linq.IQbservable source1, + System.IObservable source2, + System.IObservable source3, + System.IObservable source4, + System.IObservable source5, + System.IObservable source6, + System.IObservable source7, + System.IObservable source8, + System.IObservable source9, + System.IObservable source10, + System.IObservable source11, + System.IObservable source12, + System.IObservable source13, + System.IObservable source14, + System.IObservable source15, + System.IObservable source16, + System.Linq.Expressions.Expression> resultSelector) { } + } + [System.Reactive.Linq.LocalQueryMethodImplementationType(typeof(System.Reactive.Linq.ObservableEx))] + public static class QbservableEx + { + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second"})] + public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third"})] + public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth"})] + public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth"})] + public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth"})] + public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh"})] + public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + null})] + public static System.Reactive.Linq.IQbservable>> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + null, + null})] + public static System.Reactive.Linq.IQbservable>> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh, System.IObservable twelfth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + "Thirteenth", + null, + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh, System.IObservable twelfth, System.IObservable thirteenth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + "Thirteenth", + "Fourteenth", + null, + null, + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh, System.IObservable twelfth, System.IObservable thirteenth, System.IObservable fourteenth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + "Thirteenth", + "Fourteenth", + "Fifteenth", + null, + null, + null, + null, + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>>> CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh, System.IObservable twelfth, System.IObservable thirteenth, System.IObservable fourteenth, System.IObservable fifteenth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + "Thirteenth", + "Fourteenth", + "Fifteenth", + "Sixteenth", + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>>> CombineLatest( + this System.Reactive.Linq.IQbservable first, + System.IObservable second, + System.IObservable third, + System.IObservable fourth, + System.IObservable fifth, + System.IObservable sixth, + System.IObservable seventh, + System.IObservable eighth, + System.IObservable ninth, + System.IObservable tenth, + System.IObservable eleventh, + System.IObservable twelfth, + System.IObservable thirteenth, + System.IObservable fourteenth, + System.IObservable fifteenth, + System.IObservable sixteenth) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>>> iteratorMethod) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable Create(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression, System.Collections.Generic.IEnumerable>>> iteratorMethod) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable Expand(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable Expand(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> selector, System.Reactive.Concurrency.IScheduler scheduler) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable ForkJoin(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable ForkJoin(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable ForkJoin(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Linq.Expressions.Expression> resultSelector) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable Let(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, System.IObservable>> selector) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable ManySelect(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, TResult>> selector) { } + [System.Reactive.Experimental] + public static System.Reactive.Linq.IQbservable ManySelect(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression, TResult>> selector, System.Reactive.Concurrency.IScheduler scheduler) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second"})] + public static System.Reactive.Linq.IQbservable> WithLatestFrom(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second"})] + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservable first, System.Collections.Generic.IEnumerable second) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second"})] + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third"})] + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth"})] + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth"})] + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth"})] + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh"})] + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + null})] + public static System.Reactive.Linq.IQbservable>> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + null, + null})] + public static System.Reactive.Linq.IQbservable>> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh, System.IObservable twelfth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + "Thirteenth", + null, + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh, System.IObservable twelfth, System.IObservable thirteenth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + "Thirteenth", + "Fourteenth", + null, + null, + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh, System.IObservable twelfth, System.IObservable thirteenth, System.IObservable fourteenth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + "Thirteenth", + "Fourteenth", + "Fifteenth", + null, + null, + null, + null, + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>>> Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.IObservable third, System.IObservable fourth, System.IObservable fifth, System.IObservable sixth, System.IObservable seventh, System.IObservable eighth, System.IObservable ninth, System.IObservable tenth, System.IObservable eleventh, System.IObservable twelfth, System.IObservable thirteenth, System.IObservable fourteenth, System.IObservable fifteenth) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second", + "Third", + "Fourth", + "Fifth", + "Sixth", + "Seventh", + "Eighth", + "Ninth", + "Tenth", + "Eleventh", + "Twelfth", + "Thirteenth", + "Fourteenth", + "Fifteenth", + "Sixteenth", + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null})] + public static System.Reactive.Linq.IQbservable>>> Zip( + this System.Reactive.Linq.IQbservable first, + System.IObservable second, + System.IObservable third, + System.IObservable fourth, + System.IObservable fifth, + System.IObservable sixth, + System.IObservable seventh, + System.IObservable eighth, + System.IObservable ninth, + System.IObservable tenth, + System.IObservable eleventh, + System.IObservable twelfth, + System.IObservable thirteenth, + System.IObservable fourteenth, + System.IObservable fifteenth, + System.IObservable sixteenth) { } + } + public class QueryDebugger + { + public QueryDebugger() { } + } + public static class RemotingObservable + { + public static System.IObservable Remotable(this System.IObservable source) { } + public static System.Reactive.Linq.IQbservable Remotable(this System.Reactive.Linq.IQbservable source) { } + public static System.IObservable Remotable(this System.IObservable source, System.Runtime.Remoting.Lifetime.ILease lease) { } + public static System.Reactive.Linq.IQbservable Remotable(this System.Reactive.Linq.IQbservable source, System.Runtime.Remoting.Lifetime.ILease lease) { } + } +} +namespace System.Reactive.PlatformServices +{ + public class CurrentPlatformEnlightenmentProvider : System.Reactive.PlatformServices.IPlatformEnlightenmentProvider + { + public CurrentPlatformEnlightenmentProvider() { } + public virtual T? GetService(object[] args) + where T : class { } + } + public class DefaultSystemClock : System.Reactive.PlatformServices.ISystemClock + { + public DefaultSystemClock() { } + public System.DateTimeOffset UtcNow { get; } + } + public static class EnlightenmentProvider + { + public static bool EnsureLoaded() { } + } + public static class HostLifecycleService + { + public static event System.EventHandler? Resuming; + public static event System.EventHandler? Suspending; + public static void AddRef() { } + public static void Release() { } + } + public class HostResumingEventArgs : System.EventArgs + { + public HostResumingEventArgs() { } + } + public class HostSuspendingEventArgs : System.EventArgs + { + public HostSuspendingEventArgs() { } + } + public interface IExceptionServices + { + [System.Diagnostics.CodeAnalysis.DoesNotReturn] + void Rethrow(System.Exception exception); + } + public interface IHostLifecycleNotifications + { + event System.EventHandler Resuming; + event System.EventHandler Suspending; + } + public interface INotifySystemClockChanged + { + event System.EventHandler SystemClockChanged; + } + public interface IPlatformEnlightenmentProvider + { + T? GetService(params object[] args) + where T : class; + } + public interface ISystemClock + { + System.DateTimeOffset UtcNow { get; } + } + public class PeriodicTimerSystemClockMonitor : System.Reactive.PlatformServices.INotifySystemClockChanged + { + public PeriodicTimerSystemClockMonitor(System.TimeSpan period) { } + public event System.EventHandler SystemClockChanged; + } + public static class PlatformEnlightenmentProvider + { + public static System.Reactive.PlatformServices.IPlatformEnlightenmentProvider Current { get; set; } + } + public static class SystemClock + { + public static System.DateTimeOffset UtcNow { get; } + public static void AddRef() { } + public static void Release() { } + } + public class SystemClockChangedEventArgs : System.EventArgs + { + public SystemClockChangedEventArgs() { } + public SystemClockChangedEventArgs(System.DateTimeOffset oldTime, System.DateTimeOffset newTime) { } + public System.DateTimeOffset NewTime { get; } + public System.DateTimeOffset OldTime { get; } + } +} +namespace System.Reactive.Subjects +{ + public sealed class AsyncSubject : System.Reactive.Subjects.SubjectBase, System.Runtime.CompilerServices.INotifyCompletion + { + public AsyncSubject() { } + public override bool HasObservers { get; } + public bool IsCompleted { get; } + public override bool IsDisposed { get; } + public override void Dispose() { } + public System.Reactive.Subjects.AsyncSubject GetAwaiter() { } + public T GetResult() { } + public override void OnCompleted() { } + public void OnCompleted(System.Action continuation) { } + public override void OnError(System.Exception error) { } + public override void OnNext(T value) { } + public override System.IDisposable Subscribe(System.IObserver observer) { } + } + public sealed class BehaviorSubject : System.Reactive.Subjects.SubjectBase + { + public BehaviorSubject(T value) { } + public override bool HasObservers { get; } + public override bool IsDisposed { get; } + public T Value { get; } + public override void Dispose() { } + public override void OnCompleted() { } + public override void OnError(System.Exception error) { } + public override void OnNext(T value) { } + public override System.IDisposable Subscribe(System.IObserver observer) { } + public bool TryGetValue([System.Diagnostics.CodeAnalysis.MaybeNullWhen(false)] out T value) { } + } + public interface IConnectableObservable : System.IObservable + { + System.IDisposable Connect(); + } + public interface ISubject : System.IObservable, System.IObserver, System.Reactive.Subjects.ISubject { } + public interface ISubject : System.IObservable, System.IObserver { } + public sealed class ReplaySubject : System.Reactive.Subjects.SubjectBase + { + public ReplaySubject() { } + public ReplaySubject(int bufferSize) { } + public ReplaySubject(System.Reactive.Concurrency.IScheduler scheduler) { } + public ReplaySubject(System.TimeSpan window) { } + public ReplaySubject(int bufferSize, System.Reactive.Concurrency.IScheduler scheduler) { } + public ReplaySubject(int bufferSize, System.TimeSpan window) { } + public ReplaySubject(System.TimeSpan window, System.Reactive.Concurrency.IScheduler scheduler) { } + public ReplaySubject(int bufferSize, System.TimeSpan window, System.Reactive.Concurrency.IScheduler scheduler) { } + public override bool HasObservers { get; } + public override bool IsDisposed { get; } + public override void Dispose() { } + public override void OnCompleted() { } + public override void OnError(System.Exception error) { } + public override void OnNext(T value) { } + public override System.IDisposable Subscribe(System.IObserver observer) { } + } + public static class Subject + { + public static System.Reactive.Subjects.ISubject Create(System.IObserver observer, System.IObservable observable) { } + public static System.Reactive.Subjects.ISubject Create(System.IObserver observer, System.IObservable observable) { } + public static System.Reactive.Subjects.ISubject Synchronize(System.Reactive.Subjects.ISubject subject) { } + public static System.Reactive.Subjects.ISubject Synchronize(System.Reactive.Subjects.ISubject subject, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Reactive.Subjects.ISubject Synchronize(System.Reactive.Subjects.ISubject subject) { } + public static System.Reactive.Subjects.ISubject Synchronize(System.Reactive.Subjects.ISubject subject, System.Reactive.Concurrency.IScheduler scheduler) { } + } + public abstract class SubjectBase : System.IDisposable, System.IObservable, System.IObserver, System.Reactive.Subjects.ISubject, System.Reactive.Subjects.ISubject + { + protected SubjectBase() { } + public abstract bool HasObservers { get; } + public abstract bool IsDisposed { get; } + public abstract void Dispose(); + public abstract void OnCompleted(); + public abstract void OnError(System.Exception error); + public abstract void OnNext(T value); + public abstract System.IDisposable Subscribe(System.IObserver observer); + } + public sealed class Subject : System.Reactive.Subjects.SubjectBase + { + public Subject() { } + public override bool HasObservers { get; } + public override bool IsDisposed { get; } + public override void Dispose() { } + public override void OnCompleted() { } + public override void OnError(System.Exception error) { } + public override void OnNext(T value) { } + public override System.IDisposable Subscribe(System.IObserver observer) { } + } +} +namespace System.Reactive.Threading.Tasks +{ + public static class TaskObservableExtensions + { + public static System.IObservable ToObservable(this System.Threading.Tasks.Task task) { } + public static System.IObservable ToObservable(this System.Threading.Tasks.Task task, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable ToObservable(this System.Threading.Tasks.Task task, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.IObservable ToObservable(this System.Threading.Tasks.Task task) { } + public static System.IObservable ToObservable(this System.Threading.Tasks.Task task, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.IObservable ToObservable(this System.Threading.Tasks.Task task, System.Reactive.Concurrency.TaskObservationOptions options) { } + public static System.Threading.Tasks.Task ToTask(this System.IObservable observable) { } + public static System.Threading.Tasks.Task ToTask(this System.IObservable observable, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Threading.Tasks.Task ToTask(this System.IObservable observable, System.Threading.CancellationToken cancellationToken) { } + public static System.Threading.Tasks.Task ToTask(this System.IObservable observable, object? state) { } + public static System.Threading.Tasks.Task ToTask(this System.IObservable observable, System.Threading.CancellationToken cancellationToken, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Threading.Tasks.Task ToTask(this System.IObservable observable, System.Threading.CancellationToken cancellationToken, object? state) { } + public static System.Threading.Tasks.Task ToTask(this System.IObservable observable, object? state, System.Reactive.Concurrency.IScheduler scheduler) { } + public static System.Threading.Tasks.Task ToTask(this System.IObservable observable, System.Threading.CancellationToken cancellationToken, object? state, System.Reactive.Concurrency.IScheduler scheduler) { } + } +} +namespace System.Runtime.CompilerServices +{ + public struct TaskObservableMethodBuilder + { + public System.Reactive.ITaskObservable Task { get; } + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : System.Runtime.CompilerServices.INotifyCompletion + where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + [System.Security.SecuritySafeCritical] + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion + where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public void SetException(System.Exception exception) { } + public void SetResult(T result) { } + public void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine) { } + public void Start(ref TStateMachine stateMachine) + where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public static System.Runtime.CompilerServices.TaskObservableMethodBuilder Create() { } + } +} diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Testing.verified.cs b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Testing.verified.cs index 25afbecf8..1c990ae85 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Testing.verified.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Testing.verified.cs @@ -1,6 +1,6 @@ [assembly: System.CLSCompliant(true)] [assembly: System.Runtime.InteropServices.ComVisible(false)] -[assembly: System.Runtime.Versioning.TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName=".NET Framework 4.7.2")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName=".NET Standard 2.0")] namespace Microsoft.Reactive.Testing { public interface ITestableObservable : System.IObservable diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.cs b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.cs index e9b49fe34..da759124f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.cs @@ -25,6 +25,22 @@ public ApiApprovalTests() { } + // TODO IDG10: temporarily disabled, because PublicApiGenerator is essentially incapable of + // validating type exported facades. Even if we pass it a list of all the types we want + // to export, it makes the assumption that they are all canonically defined in the same + // assembly. + //[Fact] + //public Task LegacySystemReactive() + //{ + // var facadeAsm = typeof(System.Reactive.Placeholder).Assembly; + // ModuleDefinition module = ModuleDefinition.ReadModule(facadeAsm.Location); + // Type[] exportedTypes = module.ExportedTypes + // //.Where(et => et.IsPublic) + // .Select(et => facadeAsm.GetType(et.FullName.Replace("/", "+"))).ToArray(); + // var publicApi = GeneratePublicApi(exportedTypes); + // return Verify(publicApi, "cs"); + //} + [Fact] public Task Core() { @@ -50,7 +66,7 @@ private string GeneratePublicApi(Assembly assembly) { ApiGeneratorOptions options = new() { - AllowNamespacePrefixes = new[] { "System", "Microsoft" } + AllowNamespacePrefixes = new[] { "System", "Microsoft" }, }; return Filter(ApiGenerator.GeneratePublicApi(assembly, options)); } diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj index a324d8f2f..da7d719b1 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj +++ b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj @@ -19,9 +19,10 @@ - + + @@ -33,4 +34,11 @@ + + + $([System.String]::Copy('%(FileName)').Split('.')[0]) + %(ParentFile).cs + + + diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/AppPackages/Tests.System.Reactive.Uwp.DeviceRunner_1.0.0.0_x86_Debug_Test/Tests.System.Reactive.Uwp.DeviceRunner_1.0.0.0_x86_Debug.appx b/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/AppPackages/Tests.System.Reactive.Uwp.DeviceRunner_1.0.0.0_x86_Debug_Test/Tests.System.Reactive.Uwp.DeviceRunner_1.0.0.0_x86_Debug.appx deleted file mode 100644 index 83c89aaea..000000000 Binary files a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/AppPackages/Tests.System.Reactive.Uwp.DeviceRunner_1.0.0.0_x86_Debug_Test/Tests.System.Reactive.Uwp.DeviceRunner_1.0.0.0_x86_Debug.appx and /dev/null differ diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/Tests.System.Reactive.Uwp.DeviceRunner.csproj b/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/Tests.System.Reactive.Uwp.DeviceRunner.csproj index 7a025bb0e..60a0888f5 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/Tests.System.Reactive.Uwp.DeviceRunner.csproj +++ b/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/Tests.System.Reactive.Uwp.DeviceRunner.csproj @@ -154,9 +154,9 @@ {cb5e4ffa-f510-43f1-b378-b3d7ba7c8396} System.Reactive.Observable.Aliases - + {01706a0f-8a63-4fd6-af45-0bc0bed3c0d9} - System.Reactive + System.Reactive.Base {73078FB5-6038-4674-B4C4-32FD81B88055} diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests.System.Reactive.csproj b/Rx.NET/Source/tests/Tests.System.Reactive/Tests.System.Reactive.csproj index 65eb48bad..af8e4d0da 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests.System.Reactive.csproj +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests.System.Reactive.csproj @@ -1,4 +1,4 @@ - + net472;net6.0;net7.0;net6.0-windows10.0.19041 @@ -32,8 +32,23 @@ - + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Rx.NET/Source/version.json b/Rx.NET/Source/version.json index c3ae3ab45..d4820eba0 100644 --- a/Rx.NET/Source/version.json +++ b/Rx.NET/Source/version.json @@ -1,11 +1,12 @@ { - "version": "6.0.1-preview.{height}", + "$schema": "https://raw.githubusercontent.com/dotnet/Nerdbank.GitVersioning/main/src/NerdBank.GitVersioning/version.schema.json", + "version": "7.0-typeforwarders", + "nuGetPackageVersion": { + "semVer": 2.0 + }, "publicReleaseRefSpec": [ - "^refs/heads/main$", // we release out of main - "^refs/heads/rel/v\\d+\\.\\d+", // we also release branches starting with rel/vN.N - "^refs/heads/rel/rx-v\\d+\\.\\d+" // we also release branches starting with rel/vN.N - ], - "nugetPackageVersion":{ - "semVer": 2 - } -} + "^refs/heads/main$", + "^refs/heads/rel/v\\d+\\.\\d+", + "^refs/heads/rel/rx-v\\d+\\.\\d+" + ] +} \ No newline at end of file